@testim/testim-cli/commons/testimDesiredCapabilitiesBuilder.js

"use strict";

const {CLI_MODE, mobileWeb} = require('./constants');
const _ = require('lodash');
const fs = require('fs');
const path = require('path');
const config = require('./config');
const utils = require('../utils');
const {getAppCaps} = require('./apkUploader/apkUploaderFactory');


const LOG_LEVEL = config.WEBDRIVER_DEBUG ? 'verbose' : 'silent';
const CONTENT_SETTING = {
    CONTENT_SETTING_DEFAULT: 0,
    CONTENT_SETTING_ALLOW: 1,
    CONTENT_SETTING_BLOCK: 2,
    CONTENT_SETTING_ASK: 3,
};

function buildEdgeOptions(opts) {
    Object.assign(opts.desiredCapabilities, {
        browserName: 'MicrosoftEdge',
        _isOldEdge: true
    });

    return opts;
}

function buildSafariOptions(opts, browserName) {
    const safariOptions = { browserName: 'safari' }

    if(browserName === 'safari technology preview') {
        safariOptions['safari.options'] = { technologyPreview: true };
    }

    Object.assign(opts.desiredCapabilities, safariOptions);
    return opts;
}

function buildIEOptions(opts, browserOptions, version) {
    const ieOptions = {
        ignoreProtectedModeSettings: true,
        'ie.ensureCleanSession': true,
        'ie.enableFullPageScreenshot': false,
        'ie.fileUploadDialogTimeout': 3000
    };

    Object.assign(opts.desiredCapabilities, {
        browserName: 'internet explorer',
        version: version
    });

    if (browserOptions.oldCapabilities) {
        Object.assign(opts.desiredCapabilities, ieOptions);
    }

    if (browserOptions.w3cCapabilities) {
        opts.desiredCapabilities['se:ieOptions'] = ieOptions;
    }

    return opts;
}

function readFileToBase64(fileLocation) {
    return fs.readFileSync(fileLocation, {encoding: 'base64'});
}

function setTestimExtension(browserOptions, extensions, args) {
    if (browserOptions.ext) {
        const ext = typeof(browserOptions.ext) === 'string' ? browserOptions.ext : (__dirname + '/..');
        const loadExt = '--load-extension=' + ext;
        args.push(loadExt);
        return;
    }

    const zipFileSuffix = browserOptions.canary ? "-master.zip" : ".zip";
    const filePath = path.join(process.cwd(), "testim-headless" + zipFileSuffix);
    extensions.push(readFileToBase64(filePath));
}

function buildChromiumOptions(opts, browserOptions, testRunConfig, customExtensionLocalLocation, gridInfo) {
    const extensions = [];
    const args = [
        '--disable-popup-blocking',
        '--ignore-gpu-blacklist',
        '--auto-select-desktop-capture-source=Entire screen',
        '--ignore-certificate-errors',
    ];
    if (browserOptions.headless) {
        args.push('--headless');
    }
    //sauce labs issues - if you set w3c = true sauce search the data in capabilities instead of desiredCapabilities
    const isW3CMode = () => {
      return browserOptions.mode !== CLI_MODE.EXTENSION;
    };
    const chromiumOptions = {
        prefs: {
            'profile.default_content_setting_values.popups': CONTENT_SETTING.CONTENT_SETTING_ALLOW,
            // allow multiple download files
            'profile.default_content_setting_values.automatic_downloads': CONTENT_SETTING.CONTENT_SETTING_ALLOW,
            // disable pdf viewer
            'plugins.always_open_pdf_externally': true
        },
        w3c: isW3CMode()
    };

    if(browserOptions.chromeExtraPrefs) {
        Object.assign(chromiumOptions.prefs, browserOptions.chromeExtraPrefs);
    }

    if(browserOptions.chromeBlockLocation) {
        chromiumOptions.prefs["profile.default_content_setting_values.geolocation"] = CONTENT_SETTING.CONTENT_SETTING_BLOCK;
    }

    if(browserOptions.chromeUserDataDir) {
        args.push(`--user-data-dir=${browserOptions.chromeUserDataDir}`);
    }

    if(browserOptions.projectData && browserOptions.projectData.defaults && browserOptions.projectData.defaults.disableChromiumGpu) {
        args.push('--disable-gpu');
    }

    const browserName = testRunConfig.seleniumName || testRunConfig.browserValue;
    Object.assign(opts.desiredCapabilities, { browserName });

    function setMobileEmulationSettings() {
        if (testRunConfig.mobileEmulation) {
            chromiumOptions.mobileEmulation = {
                deviceMetrics: {
                    width: testRunConfig.mobileEmulation.device.width,
                    height: testRunConfig.mobileEmulation.device.height + mobileWeb.MOBILE_WEB_REMOTE_RUN_HEADER_SPACING,
                    pixelRatio: testRunConfig.mobileEmulation.device.deviceScaleFactor
                },
                userAgent: testRunConfig.mobileEmulation.userAgent
            };
        }
    }

    setMobileEmulationSettings();

    if (browserOptions.mode === CLI_MODE.EXTENSION) {
        setTestimExtension(browserOptions, extensions, args);
    }

    if (customExtensionLocalLocation) {
        extensions.push(readFileToBase64(customExtensionLocalLocation));
    }

    if (extensions.length > 0) {
        chromiumOptions.extensions = extensions;
    }

    chromiumOptions.args = args;
    const optionsKey = {'MicrosoftEdge': 'edgeOptions', 'chrome': 'chromeOptions'}[browserName];
    const vendor = {'MicrosoftEdge': 'ms', 'chrome': 'goog'}[browserName];

    if (browserOptions.oldCapabilities && gridInfo.type !== 'testimEnterprise') {
        opts.desiredCapabilities[optionsKey] = chromiumOptions;
    }

    if (browserOptions.w3cCapabilities || gridInfo.type === 'testimEnterprise') {
        opts.desiredCapabilities[`${vendor}:${optionsKey}`] = chromiumOptions;
    }

    return opts;
}

function buildFirefoxOptions(opts, browserOptions) {
    Object.assign(opts.desiredCapabilities, {
        acceptInsecureCerts: true,
        browserName: 'firefox',
        marionette: true,
        //disable pdf viewer. Otherwise, the pdf viewer takes over when we download a pdf.
        'moz:firefoxOptions': {
            prefs: {
                'pdfjs.disabled': true
            }
        }
    });

    if (browserOptions.mode === CLI_MODE.EXTENSION) {
        if (browserOptions.ext) {
            opts.desiredCapabilities.testim_firefox_profile = browserOptions.ext;
        } else {
            const zipFileSuffix = browserOptions.canary ? '-master.zip' : '.zip';
            const filePath = path.join(process.cwd(), 'testim-firefox-profile' + zipFileSuffix);
            opts.desiredCapabilities.firefox_profile = readFileToBase64(filePath);
        }
    }


    // more interesting options
    // https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Headless_mode#Debugging_headless_Firefox
    if (browserOptions.headless) {
        if (!opts.desiredCapabilities['moz:firefoxOptions'].args) {
            opts.desiredCapabilities['moz:firefoxOptions'].args = [];
        }
        opts.desiredCapabilities['moz:firefoxOptions'].args.push('-headless');
    };

    return opts;
}

function buildSaucelabs(browserOptions, testName, testRunConfig) {
    if (browserOptions.saucelabs && browserOptions.saucelabs.username && browserOptions.saucelabs.accessKey) {
        if (testRunConfig) {
            testRunConfig.sl.version = testRunConfig.browserValue === 'safari' ? testRunConfig.sl.safari_version : testRunConfig.sl.version;
            testRunConfig.sl.appiumVersion = browserOptions.saucelabs.appiumVersion || testRunConfig.sl.appiumVersion;
            return Object.assign({}, testRunConfig.sl, browserOptions.saucelabs, {name: testName});
        }
        return Object.assign({}, browserOptions.saucelabs, {name: testName});
    }
    return {};
}

function buildBrowserstack(browserOptions, testName, testRunConfig) {
    if (!_.isEmpty(browserOptions.browserstack)) {
        if (testRunConfig) {
            testRunConfig.bs.browser_version = testRunConfig.browserValue === 'safari' ? testRunConfig.bs.safari_version : testRunConfig.bs.browser_version;
            if (testRunConfig.browserValue === 'safari' && testRunConfig.bs.safari_version === '10') {
                Object.assign(testRunConfig.bs, {'safari.options': {'technologyPreview': true}});
            }
            return Object.assign({}, testRunConfig.bs, browserOptions.browserstack, {name: testName});
        }
        return Object.assign({}, browserOptions.browserstack, {name: testName});
    }
    return {};
}

function buildPerfecto(browserOptions) {
    if (browserOptions.perfecto) {
        return browserOptions.perfecto;
    }
    return {};
}

function buildExperitest(browserOptions, browser, sessionTimeoutSec) {

    if (browserOptions.experitestToken) {
        const isSafari = browser === 'safari';
        return {
            accessKey: browserOptions.experitestToken,
            browserVersion: 'latest',
            platformName: isSafari ? 'MAC' : 'WIN10',
            //Workaround to Experitest bug in take screenshot in Safari browser
            seleniumScreenshot: isSafari,
            newSessionWaitTimeout: sessionTimeoutSec
        };
    }

    return {};
}

function getConnectionRetryTimeout(browserOptions) {
    const browserTimeout = browserOptions.browserTimeout;
    const MIN_TIMEOUT = 90000;
    return browserTimeout < MIN_TIMEOUT ? MIN_TIMEOUT : browserTimeout;
}

function buildHeaders(browserOptions) {
    const headers = {};
    if (typeof browserOptions.gridUsername !== "undefined" && typeof browserOptions.gridPassword !== "undefined") {
        headers.Authorization = utils.buildBasicHeader(browserOptions.gridUsername, browserOptions.gridPassword);
    }
    return headers;
}

function buildSeleniumOptions(browserOptions, testName, testRunConfig, gridInfo, customExtensionLocalLocation) {
    if (gridInfo.mode === 'local') {
        const extensions = [];

        const args = [];

        if (browserOptions.headless) {
            args.push("--headless");
        }

        if (browserOptions.silentDebuggerExtensionApi) {
            args.push("--silent-debugger-extension-api");
        }

        if (browserOptions.remoteDebuggingPort !== undefined) {
            args.push(`--remote-debugging-port=${browserOptions.remoteDebuggingPort}`);
        }

        if (browserOptions.mode !== 'selenium') {
            setTestimExtension(browserOptions, extensions, args);
        }

        return {
            logLevel: LOG_LEVEL,
            desiredCapabilities: {
                chromeOptions: {
                    args,
                    extensions
                },
                browserName: 'chrome'
            },
            host: 'localhost',
            port: 9515 // chromedriver port
          };
    }

    const headers = buildHeaders(browserOptions);
    let opts = {
        host: gridInfo.host,
        port: gridInfo.port || 4444,
        path: gridInfo.path || '/wd/hub',
        protocol: gridInfo.protocol || 'http',
        logLevel: LOG_LEVEL,
        connectionRetryTimeout: getConnectionRetryTimeout(browserOptions),
        desiredCapabilities: {
            acceptSslCerts: true,
            unexpectedAlertBehaviour: "accept", // What the browser should do with an unhandled alert before throwing out the UnhandledAlertException - automatically click on accept
            nativeEvents: true,
            testName
        },
        deprecationWarnings: false
    };

    if (!_.isEmpty(headers)) {
        opts.headers = headers;
    }

    if (browserOptions.proxyForGrid) {
        opts.agent = new global.ProxyAgent(global.proxyUri);
    }

    if (browserOptions.disableNativeEvents) {
        opts.desiredCapabilities.nativeEvents = false;
    }

    if (gridInfo.user && gridInfo.key) {
        if (gridInfo.type === "saucelabs") {
            browserOptions.saucelabs = browserOptions.saucelabs || {};
            browserOptions.saucelabs.username = browserOptions.saucelabs.username || gridInfo.user;
            browserOptions.saucelabs.accessKey = browserOptions.saucelabs.accessKey || gridInfo.key;
        }

        if (gridInfo.type === "browserstack") {
            browserOptions.browserstack = browserOptions.browserstack || {};
            browserOptions.browserstack['browserstack.user'] = browserOptions.browserstack['browserstack.user'] || gridInfo.user;
            browserOptions.browserstack['browserstack.key'] = browserOptions.browserstack['browserstack.key'] || gridInfo.key;
        }
    }

    if (gridInfo.key && gridInfo.type === "perfecto") {
        browserOptions.perfecto.securityToken = gridInfo.key;
    }

    const browserTimeoutSec = parseInt(browserOptions.browserTimeout / 1000);
    const browser = browserOptions.browser || (testRunConfig && testRunConfig.browserValue);

    Object.assign(
        opts.desiredCapabilities,
        buildSaucelabs(browserOptions, testName, testRunConfig),
        buildBrowserstack(browserOptions, testName, testRunConfig),
        buildPerfecto(browserOptions, testName, testRunConfig),
        buildExperitest(browserOptions, browser, browserTimeoutSec));

    if (!browserOptions.ext && _.endsWith(gridInfo.host, '.testim.io') && !browserOptions.canary && browserOptions.mode === CLI_MODE.EXTENSION) {
        if (browser === 'chrome') {
            browserOptions.ext = '/opt/testim-headless';
        } else if (browser === 'edge-chromium') {
            browserOptions.ext = 'C:/selenium/testim-headless';
        } else if (browser === 'firefox') {
            browserOptions.ext = '/opt/testim-firefox-profile';
        }
    }



    if (_.endsWith(gridInfo.host, '.testim.io') && browser === 'edge-chromium') {
        opts.desiredCapabilities.version = '83'; // Need to match GGR filter
    }

    switch (browser) {
        case 'chrome':
        case 'edge-chromium':
            opts = buildChromiumOptions(opts, browserOptions, testRunConfig, customExtensionLocalLocation, gridInfo);
            break;
        case 'firefox':
            opts = buildFirefoxOptions(opts, browserOptions);
            break;
        case 'edge':
            opts = buildEdgeOptions(opts);
            break;
        case 'safari':
        case 'safari technology preview':
            opts = buildSafariOptions(opts, browser);
            break;
        case 'ie11':
            opts = buildIEOptions(opts, browserOptions, "11");
            break;
    }

    _.merge(opts.desiredCapabilities, browserOptions.seleniumCapsFileContent);

    return opts;
}

function buildTestObject(browserOptions, testName, appCaps) {
    if (!_.isEmpty(browserOptions.testobjectSauce)) {
        return Object.assign({
            "idleTimeout": 30,
            "testobject_test_name": testName,
            "testobject_session_creation_timeout": String(browserOptions.browserTimeout),
            deviceName: null
        }, appCaps, browserOptions.testobjectSauce);
    }
    return {};
}

function buildSaucelabsMobile(browserOptions, testName, appCaps) {
    if (!_.isEmpty(browserOptions.saucelabs)) {
        return Object.assign({
            deviceName: null,
            name: testName,
            "idleTimeout": 30,
            browserName: ""
        }, appCaps, browserOptions.saucelabs);
    }
    return {};
}

function buildAppiumOptions(browserOptions, gridInfo, nativeAppData, testName) {
    let opts = {
        host: gridInfo.host,
        port: gridInfo.port || 4444,
        path: gridInfo.path || '/wd/hub',
        protocol: gridInfo.protocol || 'http',
        logLevel: LOG_LEVEL,
        connectionRetryTimeout: getConnectionRetryTimeout(browserOptions),
        desiredCapabilities: {
            browserName: "",
            "noReset": false,
            "fullReset": false,
        },
    };

    if(browserOptions.projectData.type === "android") {
        Object.assign(
            opts.desiredCapabilities, {
                appPackage: nativeAppData.packageName,
                appActivity: nativeAppData.activity,
                "platformName": "Android",
                "automationName": 'uiautomator2',
                "autoLaunch": false,
                "ignoreUnimportantViews": false,
                "disableWindowAnimation": browserOptions.disableWindowAnimation
            }
        );
    } else if (browserOptions.projectData.type === "ios") {
        Object.assign(
            opts.desiredCapabilities, {
                bundleId: nativeAppData.packageName,
                "platformName": "iOS",
                "automationName": 'XCUITest',
            }
        );
    }

    if(browserOptions.deviceUdid) {
        opts.desiredCapabilities.udid = browserOptions.deviceUdid;
    }

    if(browserOptions.deviceName) {
        opts.desiredCapabilities.deviceName = browserOptions.deviceName;
    }

    if (gridInfo.user && gridInfo.key && gridInfo.type === "saucelabs") {
        browserOptions.saucelabs = browserOptions.saucelabs || {};
        browserOptions.saucelabs.username = browserOptions.saucelabs.username || gridInfo.user;
        browserOptions.saucelabs.accessKey = browserOptions.saucelabs.accessKey || gridInfo.key;
    } else if (gridInfo.key && gridInfo.type === "testobject") {
        browserOptions.testobjectSauce = browserOptions.testobjectSauce || {};
        browserOptions.testobjectSauce.testobjectApiKey = browserOptions.testobjectSauce.testobjectApiKey || gridInfo.key;
    } else if (gridInfo.key && gridInfo.type === "perfecto") {
        browserOptions.perfecto = browserOptions.perfecto || {};
        browserOptions.perfecto.securityToken = gridInfo.key;
    }

    const appCaps = getAppCaps(gridInfo);

    Object.assign(
        opts.desiredCapabilities,
        buildTestObject(browserOptions, testName, appCaps),
        buildSaucelabsMobile(browserOptions, testName, appCaps)
    );

    return opts;
}

module.exports = {
    buildSeleniumOptions: buildSeleniumOptions,
    buildAppiumOptions: buildAppiumOptions
};