@testim/testim-cli 3.196.0 → 3.200.0

package/runners/SchedulerRemoteRunner.js

@@ -1,47 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-const config = require('../commons/config');
-const testimCustomToken = require('../commons/testimCustomToken');
-const BaseRunner = require('./BaseRunner');
-const TestRunStatus = require('../testRunStatus');
-const reporter = require("../reports/reporter");
-const guid = require('../utils').guid;
-const Logger = require('../commons/logger');
-const logger = Logger.getLogger('remote-test-runner');
-
-class SchedulerRemoteRunner extends BaseRunner {
-    runExecution(testList, testStatus, executionId, options, branchToUse) {
-        const sessionType = utils.getSessionType(options);
-        const projectId = options.project;
-        // report exec start analytics
-        const authData = testimCustomToken.getTokenV3UserData();
-        this.analyticsExecsStart({authData, executionId, projectId, sessionType});
-        const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || options.parallel;
-
-        return this.strategy.runTests(testList, testStatus, executionId, options, branchToUse, authData, workerCount);
-    }
-
-    runTest(options, branchToUse) {
-        const executionId = options.executionId || guid();
-        const test = options.testObject;
-        Logger.setExecutionId(executionId);
-
-        logger.info("start to run test", {
-            executionId: executionId,
-            options: Object.assign({}, options, {token: undefined}),
-            branchToUse: branchToUse,
-            test: test
-        });
-
-        const testArray = [test];
-        const testPlanName = options.overrideExecutionName || "remote run";
-        const testStatus = new TestRunStatus(testArray, options, null, branchToUse);
-        reporter.onTestPlanStarted([], testArray, [], testPlanName, executionId);
-        return this.runExecution(testArray, testStatus, executionId, options, branchToUse)
-            .tap(results => reporter.onTestPlanFinished(results, testPlanName, this.startTime, executionId))
-            .then(combinedTestResults => combinedTestResults);
-    }
-}
-
-module.exports = SchedulerRemoteRunner;

package/runners/strategies/BaseStrategy.js

@@ -1,86 +0,0 @@
-'use strict';
-
-const analytics = require('../../commons/testimAnalytics');
-const { isCi } = require('../../cli/isCiRun');
-
-const calcSource = (source, user) => {
-    if (source !== 'cli' && source !== 'cli-local') {
-        return source;
-    }
-
-    if (isCi && user) {
-        return 'ci-with-user';
-    }
-
-    if (isCi) {
-        return 'ci';
-    }
-
-    if (user) {
-        return 'cli-with-user';
-    }
-
-    return source;
-};
-
-function setLightweightAnalytics(properties, lightweightMode) {
-    if (lightweightMode && lightweightMode.type) {
-        properties[`${lightweightMode.type}Mode`] = true;
-    }
-    return properties;
-}
-
-class BaseStrategy {
-    analyticsTestStart({
-        executionId, projectId, testId, resultId, companyId, companyName, projectName, companyPlanType, sessionType, source, user, lightweightMode,
-    }) {
-        const properties = setLightweightAnalytics({
-            executionId,
-            projectId,
-            testId,
-            resultId,
-            companyId,
-            companyName,
-            projectName,
-            companyPlanType,
-            sessionType,
-            source: calcSource(source, user),
-        }, lightweightMode);
-        analytics.trackWithCIUser('test-run-ci', properties);
-    }
-
-    analyticsTestEnd({
-        executionId, projectId, testId, resultId, result, companyId, companyName, projectName, companyPlanType, sessionType, source, user, lightweightMode,
-        logger,
-    }) {
-        try {
-            const properties = setLightweightAnalytics({
-                executionId,
-                projectId,
-                testId,
-                resultId,
-                companyId,
-                companyName,
-                projectName,
-                companyPlanType,
-                sessionType,
-                mockNetworkEnabled: result.wasMockNetworkActivated,
-                source: calcSource(source, user),
-            }, lightweightMode);
-
-            if (result.success) {
-                analytics.trackWithCIUser('test-run-ci-success', properties);
-                return;
-            }
-            analytics.trackWithCIUser('test-run-ci-fail', Object.assign({}, properties, { failureReason: result.failureReason }));
-        } catch (err) {
-            logger.error('failed to update test end analytics', { err });
-        }
-    }
-
-    runTests(testList, testStatus, executionId, options, branchToUse, authData, workerCount, stopOnError) {
-        throw new Error('need to implement on child');
-    }
-}
-
-module.exports = BaseStrategy;

package/runners/strategies/DeviceFarmStrategy.js

@@ -1,195 +0,0 @@
-'use strict';
-
-const Promise = require('bluebird');
-const _ = require('lodash');
-const { CLI_MODE, runnerTestStatus } = require('../../commons/constants');
-const BaseStrategy = require('./BaseStrategy');
-const config = require('../../commons/config');
-const { deviceFarm, testRunStatus } = require('../../commons/constants');
-const logger = require('../../commons/logger').getLogger('deviceFarm-strategy');
-const utils = require('../../utils');
-const RealDataService = require('../../commons/socket/realDataService');
-const { getBrowserWithRetries: getDeviceWithRetries } = require('../../workers/workerUtils');
-const { GetBrowserError, ArgError } = require('../../errors');
-const { getAppCaps } = require('../../commons/apkUploader/apkUploaderFactory');
-const reporter = require('../../reports/reporter');
-const BaseWorker = require('../../workers/BaseWorker');
-
-const testimServicesApi = require('../../commons/testimServicesApi');
-const gridService = require('../../services/gridService');
-
-const MAX_EXECUTION_TIMEOUT = 150 * 60 * 1000; //150 min is the maximum allowed by device farm
-const STATUS_CHECK_INTERVAL = 20000;
-
-const DF_RUN_STATUS = deviceFarm.status;
-const DF_RUN_RESULT = deviceFarm.result;
-const TESTIM_RUN_STATUS = testRunStatus;
-
-class DeviceFarmStrategy extends BaseStrategy {
-    constructor() {
-        super();
-        this.lastDeviceFarmStatus = DF_RUN_STATUS.INITIALIZING;
-    }
-
-    getDeviceFarmRunStatus(projectId, runArn) {
-        return testimServicesApi.getDeviceFarmRun(projectId, runArn)
-            .then(runInfo => {
-                if (this.lastDeviceFarmStatus !== runInfo.status) {
-                    logger.info(`DeviceFarm run status changed from: ${this.lastDeviceFarmStatus} to ${runInfo.status}`);
-                    this.lastDeviceFarmStatus = runInfo.status;
-                }
-                if ([DF_RUN_STATUS.COMPLETED, DF_RUN_STATUS.STOPPING].includes(runInfo.status)) {
-                    return runInfo;
-                }
-                throw new Error('still running');
-            });
-    }
-
-    convertTestResultObjectStatusToReportFormat(executionResults) {
-        Object.keys(executionResults).forEach(resultId => {
-            executionResults[resultId].status = executionResults[resultId].success ? runnerTestStatus.PASSED : runnerTestStatus.FAILED;
-        });
-        return executionResults;
-    }
-
-    convertTestResultArrayStatusToReportFormat(executionResults) {
-        executionResults.forEach(result => {
-            result.status = result.success ? runnerTestStatus.PASSED : runnerTestStatus.FAILED;
-        });
-        return executionResults;
-    }
-
-    buildConfiguration(testList) {
-        const { overrideTestConfig } = _.uniqBy(testList, 'overrideTestConfig.name')[0];
-        if (_.isEmpty(overrideTestConfig)) {
-            return {};
-        }
-        const configuration = Object.assign({}, overrideTestConfig);
-        const [platformName, platformVersion] = configuration.os.split(' ');
-
-        return {
-            platformName,
-            deviceName: configuration.browser,
-            platformVersion,
-        };
-    }
-
-    buildDeviceFarmConfiguration(options) {
-        const validateOptionKeys = (option) => {
-            const { deviceName, platformVersion /*platformName, appiumVersion,*/ } = option;
-            return deviceName && platformVersion;
-        };
-        const mapOptionToConfig = (option) => ({
-            deviceName: option.deviceName,
-            platformVersion: option.platformVersion,
-        });
-
-        if (_.isArray(options)) {
-            return options.filter(validateOptionKeys).map(mapOptionToConfig);
-        }
-        return validateOptionKeys(options) ? mapOptionToConfig(options) : {};
-    }
-
-    runTests(testList, testStatus, executionId, options, branchToUse, authData, workerCount, stopOnError) {
-        if (testList && testList.length === 0) {
-            return Promise.resolve();
-        }
-        const executionResults = {};
-        const projectId = options.project;
-        const companyId = options.company.companyId;
-        const workerId = BaseWorker.getWorkerId();
-        const testResultId = '';
-
-        const getBrowserTimeout = options.browserTimeout;
-        const newBrowserWaitTimeout = options.newBrowserWaitTimeout;
-
-        const configuration = this.buildConfiguration(testList);
-        if (_.isEmpty(configuration)) {
-            return Promise.reject(new ArgError('--test-config is missing or not properly used'));
-        }
-
-        const realDataService = new RealDataService();
-        const releaseSlotOnTestFinished = true;
-        const callbacksForGetDeviceRetryLogic = {
-            getBrowserOnce() {
-                reporter.onGetSession(workerId, `for execution ${executionId}`, CLI_MODE.APPIUM);
-                return gridService.getGridSlot(configuration.platformName, executionId, testResultId, () => {}, options, workerId);
-            },
-            testPlayerFactory: () => {}, // no factory since this is a remote run
-            releaseSlotOnTestFinished,
-        };
-        const deviceFetchConfig = {
-            totalTimeoutDuration: newBrowserWaitTimeout,
-            singleGetBrowserDuration: getBrowserTimeout,
-            projectId,
-            workerId,
-            reporter,
-        };
-        return realDataService.init(projectId)
-            .then(() => getDeviceWithRetries(callbacksForGetDeviceRetryLogic, deviceFetchConfig)).then(gridInfo => {
-                const allowedRemoteRunEnv = Object.keys(config);
-                const env = _.reduce(process.env, (envObj, value, key) => {
-                    if (allowedRemoteRunEnv.includes(key)) {
-                        envObj[key] = value;
-                    }
-                    return envObj;
-                }, {});
-
-                const remoteRunObject = {
-                    gridInfo,
-                    testList,
-                    echoedOptions: {
-                        disableWindowAnimation: options.disableWindowAnimation,
-                        baseUrl: options.baseUrl,
-                    },
-                };
-                const projectArn = gridInfo.arn;
-                const { appArn } = getAppCaps(gridInfo);
-                reporter.onWaitForDevice(workerId, executionId);
-                realDataService.joinToTestResultsByRunId(executionId, projectId);
-                return testimServicesApi.createDeviceFarmRun(companyId, projectId, projectArn, appArn, configuration, branchToUse, executionId, env, remoteRunObject);
-            }).then(run => {
-                realDataService.listenToTestResultsByRunId(executionId, testResult => {
-                    const prevTestResult = executionResults[testResult.id];
-                    const mergedTestResult = _.merge({}, prevTestResult, testResult, { resultId: testResult.id });
-                    if (!prevTestResult || prevTestResult.status !== testResult.status) {
-                        if ([TESTIM_RUN_STATUS.RUNNING].includes(testResult.status)) {
-                            testStatus.testStart(workerId, executionId, mergedTestResult.id);
-                        }
-                        if ([TESTIM_RUN_STATUS.COMPLETED].includes(testResult.status)) {
-                            testStatus.testEnd(workerId, Object.assign({}, mergedTestResult), executionId);
-                        }
-                    }
-                    executionResults[testResult.id] = mergedTestResult;
-                });
-                return utils.runWithRetries(
-                    () => this.getDeviceFarmRunStatus(projectId, run.arn), MAX_EXECUTION_TIMEOUT, STATUS_CHECK_INTERVAL);
-            })
-            .then(runInfo => {
-                if ([DF_RUN_RESULT.SKIPPED].includes(runInfo.result) &&
-                    runInfo.deviceSelectionResult &&
-                    runInfo.deviceSelectionResult.matchedDevicesCount === 0) {
-                    console.log('Device Farm Error: The device in your configuration is not supported');
-                }
-                if ([DF_RUN_RESULT.STOPPED].includes(runInfo.result)) {
-                    console.log('Device Farm Error: The test has been stopped. Please try running it again in a few minutes');
-                }
-                if ([DF_RUN_RESULT.ERRORED].includes(runInfo.result)) {
-                    console.log(`Device Farm Error: ${runInfo.message}`);
-                    return testStatus.markAllQueuedTests(executionId, runnerTestStatus.ABORTED, 'aborted', false);
-                }
-                // Results from socket (currently unused).
-                this.convertTestResultObjectStatusToReportFormat(executionResults);
-                // Results from server.
-                return testimServicesApi.getRealData(projectId, 'testResult', `runId=${executionId}&sort=runOrder`)
-                    .then(res => this.convertTestResultArrayStatusToReportFormat(res.data.docs));
-            })
-            .catch(GetBrowserError, err => testStatus.markAllQueuedTests(executionId, runnerTestStatus.FAILED, err.message, false))
-            .finally(() => {
-                realDataService.stopListenToTestResultsByRunId();
-                return gridService.releaseGridSlot(workerId, projectId);
-            });
-    }
-}
-
-module.exports = DeviceFarmStrategy;

package/runners/strategies/LocalDeviceFarmStrategy.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const LocalStrategy = require('./LocalStrategy');
-
-class LocalDeviceFarmStrategy extends LocalStrategy {
-    startWorker(worker, options, onTestStarted, onTestCompleted, executionId, onGridSlot, onTestIgnored) {
-        const releaseSlotOnTestFinished = false;
-        worker.start(options, onTestStarted, onTestCompleted, executionId, onGridSlot, onTestIgnored, releaseSlotOnTestFinished);
-    }
-}
-
-module.exports = LocalDeviceFarmStrategy;

package/runners/strategies/LocalTestStrategy.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const LocalStrategy = require('./LocalStrategy');
-const perf = require('../../commons/performance-logger');
-
-class LocalTestStrategy extends LocalStrategy {
-    startWorker(worker, options, onTestStarted, onTestCompleted, executionId, onGridSlot, onTestIgnored) {
-        const releaseSlotOnTestFinished = true;
-        perf.log('right before worker.start in startWorker');
-        worker.start(options, onTestStarted, onTestCompleted, executionId, onGridSlot, onTestIgnored, releaseSlotOnTestFinished);
-    }
-}
-
-module.exports = LocalTestStrategy;

package/runners/strategies/Strategy.js

@@ -1,17 +0,0 @@
-const LocalDeviceFarmStrategy = require('./LocalDeviceFarmStrategy');
-const LocalTestStrategy = require('./LocalTestStrategy');
-const DeviceFarmStrategy = require('./DeviceFarmStrategy');
-const {CLI_MODE} = require('../../commons/constants');
-
-module.exports = (options, customExtensionLocalLocation) => {
-    const {projectData, gridData, mode} = options;
-    if (["android", "ios"].includes(projectData.type) && gridData.type === "testimMobile") {
-        options.mode = CLI_MODE.APPIUM;
-        return new DeviceFarmStrategy();
-    }
-    if (["android", "ios"].includes(projectData.type) && mode === CLI_MODE.DEVICE_FARM_APPIUM) {
-        return new LocalDeviceFarmStrategy();
-    }
-
-    return new LocalTestStrategy(customExtensionLocalLocation);
-};

package/workers/WorkerAppium.js

@@ -1,70 +0,0 @@
-"use strict";
-
-const {CLI_MODE} = require('../commons/constants');
-const BaseWorker = require('./BaseWorker');
-const {timeoutMessages} = require('../commons/constants');
-const logger = require('../commons/logger').getLogger("worker-selenium");
-const Promise = require('bluebird');
-const exec = Promise.promisify(require('child_process').exec);
-const reporter = require("../reports/reporter");
-const MobileTestPlayer = require('../player/mobile/mobileTestPlayer');
-const { manifestVersion } = require('../commons/getSessionPlayerRequire');
-
-class WorkerAppium extends BaseWorker {
-    initPlayer(testRunHandler) {
-        const { projectData } = this.options;
-        return new MobileTestPlayer(this.id, testRunHandler.getRunParams(), projectData.type);
-    }
-
-    async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
-        player.clearSessionTabs();
-        const { driver } = player;
-
-        try {
-            await driver.init(this.options, gridInfo, testRunHandler.getNativeAppData(), this.testName, this.testResultId);
-            return player.addTab();
-        } catch (err) {
-            logger.error(`failed to get device/app (message=${err.message})`, { err });
-            throw err;
-        }
-    }
-
-    runTestCleanup() {
-        const { mode } = this.options;
-
-        if(mode === CLI_MODE.DEVICE_FARM_APPIUM) {
-            return exec("adb shell pm clear $DEVICEFARM_APP_NAME");
-        }
-        return Promise.resolve();
-    }
-
-    runTestOnce(testRunHandler, player) {
-        const version = manifestVersion || "runner";
-        let that = this;
-
-        reporter.onWaitToTestComplete(this.id, this.isCodeMode);
-
-        function runSeleniumTest() {
-            return new Promise(resolve => player.sessionPlayer.playByTestId(that.testId, that.executionId, that.testResultId, that.baseUrl, that.userData, version, resolve, false, that.overrideTestConfigId, that.branch))
-                .timeout(that.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                .catch(Promise.TimeoutError, err => {
-                    player.sessionPlayer.stopPlayingOnTestTimeout && player.sessionPlayer.stopPlayingOnTestTimeout();
-                    throw err;
-                })
-                .then(testResult => {
-                    testResult.stepsResults = null;
-                    return Promise.resolve(testResult);
-                });
-        }
-
-        return super.runTestOnce(testRunHandler, player)
-            .then(() => runSeleniumTest())
-            .catch(err => {
-                logger.error("failed to run test once", {err: err});
-                return Promise.reject(err);
-            });
-    }
-}
-
-module.exports = WorkerAppium;