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

// @ts-check

// @ts-ignore
const Promise = require('bluebird');
const { ArgError } = require('../errors');
const path = require("path");
const util = require('../utils');
const httpRequest = require('./httpRequest');
const fs = Promise.promisifyAll(require('fs'));
const localRunnerCache = require('./runnerFileCache');
const {
    getCliLocation, isURL, downloadAndSave, getSource, getLocalFileSizeInMB, download, unzipFile
} = require('../utils');
const ms = require("ms");
const config = require('../commons/config');
const { requireWithFallback } = require("./requireWithFallback");

const logger = require('./logger').getLogger('prepare runner and testim start');

const MSEC_IN_HALF_DAY = ms("0.5 day");
const MAX_CUSTOM_EXT_SIZE_MB = 16;
const MAX_CUSTOM_SIZE_ERROR_MSG = `The size of the custom extension is more than ${MAX_CUSTOM_EXT_SIZE_MB}MB`;

module.exports = {
    prepareChromeDriver,
    prepareCustomExtension,
    prepareExtension,
    getSessionPlayerFolder,
    preparePlayer
};

/**
 * @param {string} location
 */
function prepareCustomExtension(location) {
    if (!location) {
        return Promise.resolve();
    }

    if (isURL(location)) {
        const destFile = path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
        return getRemoteFileSizeInMB(location)
            .then(contentLength => {
                if (contentLength > MAX_CUSTOM_EXT_SIZE_MB) {
                    return Promise.reject(new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG));
                }
                return downloadAndSave(location, destFile);
            })
            .then(() => Promise.resolve(destFile));
    }

    const destFile = path.resolve(location);
    if (!fs.existsSync(destFile)) {
        return Promise.reject(new ArgError(`Failed to find custom extension in location: ${destFile}`));
    }
    const fileSize = getLocalFileSizeInMB(destFile);
    if (fileSize > MAX_CUSTOM_EXT_SIZE_MB) {
        return Promise.reject(new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG));
    }
    return Promise.resolve(destFile);
}


/**
 * @param {string} url
 */
function getRemoteFileSizeInMB(url) {
    const httpRequest = require('../commons/httpRequest');
    return httpRequest.head(url)
        .then(res => {
            const contentLengthHeader = res.headers["content-length"];
            const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader) : 0;
            return Promise.resolve(contentLengthBytes / 1000000);
        })
        .catch(err => {
            logger.warn(`failed to download custom extension`, { err });
            return Promise.reject(new ArgError(`Failed to download custom extension from location: ${url}`));
        });
}

/**
 *
 * @param {string[]} locations
 *
 */
function prepareExtension(locations) {
    logger.info("prepare extension", { locations: locations });
    return Promise.map(locations, location => getSource(location));
}


async function prepareChromeDriver() {
    const ora = require('ora');
    const npmWrapper = require('./npmWrapper');
    const { getChromeVersion } = require('@testim/chrome-version');

    const chromeVersion = await getChromeVersion();

    if (!chromeVersion) {
        console.log(`Chrome browser not found and is needed to locally run Testim.
1. If Chrome is installed, please add the Chrome binary directory to your PATH environment variables.
2. If you do not have Chrome, please install it from https://www.google.com/chrome`);
// For more information see: https://help.testim.io/docs/add-a-doc-with-instructions-for-win-and-linux-here

        process.exit(1);
    }

    const chromeMajorVersion = chromeVersion.substr(0, chromeVersion.indexOf('.'));

    process.env.NODE_OPTIONS = ''; // removes --inspect before starting chromeDriver

    const isChromedriverInstalled = npmWrapper.getPackageIfInstalledLocally('chromedriver');
    let isChromeDriverInTheRightVersion;
    if (isChromedriverInstalled) {
        const currentChromeDriverVersion = npmWrapper.getLocallyInstalledPackageVersion(getCliLocation(), 'chromedriver');

        const chromeDriverMajorVersion = currentChromeDriverVersion.substr(0, currentChromeDriverVersion.indexOf('.'));
        isChromeDriverInTheRightVersion = chromeDriverMajorVersion === chromeMajorVersion;
        if (!isChromeDriverInTheRightVersion) {
            console.log(`Updating ChromeDriver version from ${chromeDriverMajorVersion} to ${chromeMajorVersion}...`);
        }
    }

    if (!isChromedriverInstalled || !isChromeDriverInTheRightVersion) {
        const spinner = ora('No selenium grid detected. Installing ChromeDriver...').start();
        try {
            await npmWrapper.installPackageLocally(getCliLocation(), `chromedriver@${chromeMajorVersion}`);
            spinner.succeed('ChromeDriver installed successfully');
        } catch (err) {
            try {
                await npmWrapper.installPackageLocally(getCliLocation(), `chromedriver@latest`);
            } catch (e) {
                console.log('\nLocal ChromeDriver installation failed, please provide selenium grid details with the --host flag');
                process.exit(1);
            }
        }
    } else {
        console.log('Using local browser');
    }

    await startChromeDriver([
        '--url-base=/wd/hub', // webdriverio expects a wd hub - so we scam it it's facing selenium server
        // Disable built-in Google Translate service
        '--disable-features=TranslateUI',
        // Disable various background network services, including extension updating,
        // safe browsing service, upgrade detector, translate, UMA
        '--disable-background-networking',
        // Disable syncing to a Google account
        '--disable-sync',
        // Disable reporting to UMA, but allows for collection
        '--metrics-recording-only',
        // Disable installation of default apps on first run
        '--disable-default-apps',
        // Mute any audio
        '--mute-audio',
        // Skip first run wizards
        '--no-first-run',
        // don't complain about driver version
        '--disable-build-check'
    ]);

}

/**
 * @param {string[]} args
 */
async function startChromeDriver(args) {
    // code copied from
    // https://github.com/giggio/node-chromedriver/blob/master/lib/chromedriver.js#L21-L47
    // sans piping
    const chromeDriver = requireWithFallback('chromedriver');

    let { path: command } = chromeDriver;
    if (!fs.existsSync(command)) {
        command = process.platform === 'win32' ? 'chromedriver.exe' : 'chromedriver';
    }

    if (!fs.existsSync(command)) {
        throw new Error("chromedriver command not found");
    }

    const ora = require('ora');
    const spinner = ora('Starting Driver').start();

    const isChromedriverAlreadyRunning = await httpRequest.get('http://localhost:9515/wd/hub/status')
        .then(({value}) => value.ready)
        .catch(() => false);

    if (isChromedriverAlreadyRunning) {
        // this is fine, this means both chromedriver is running and with our prefix of /wd/hub
        // we don't have to start it again although this is risky since someone else owns its lifetime
        spinner.succeed('Driver already running');
        return;
    }

    chromeDriver.defaultInstance = require('child_process').spawn(command, args);

    // 100 tries, every 30ms
    const serverUp = await util.runWithRetries(() => httpRequest.get('http://localhost:9515/wd/hub/status'), 100, 30);

    if (serverUp && serverUp.value && serverUp.value.ready) {
        spinner.succeed('Driver Successfully Started');
        return;
    }

    // check for either IPv6 port not available or IPv4 port not available
    const prompts = require('prompts');
    const answer = await prompts({
        type: 'toggle',
        name: 'killChromedriver',
        initial: 'yes',
        active: 'yes',
        inactive: 'no',
        message: 'ChromeDriver port already taken - would you like us to try and restart it?'
    });
    if (!answer.killChromedriver) {
        throw new ArgError("Driver port already taken, please close any other Testim instances running");
    }
    await Promise.all([
        httpRequest.getText('http://localhost:9515/wd/hub/shutdown'), // us
        httpRequest.getText('http://localhost:9515/shutdown') // someone else
    ]).catch(() => {});
    // arbitrary long delay since what we're actually waiting for is for the OS to release the port
    await Promise.delay(10);
    await startChromeDriver(args);
}


function getPlayerVersion() {
    const url = 'https://testimstatic.blob.core.windows.net/extension/sessionPlayer_LATEST_RELEASE';
    return download(url)
        .then(res => Promise.resolve(res.body.toString('utf8')));
}

/**
 * @param {string} location
 * @param {string | undefined} canary
 *
 * @returns {Promise<string>}
 */
function getPlayerLocation(location, canary) {
    if (!isURL(location) || (isURL(location) && canary) || config.IS_ON_PREM) {
        return Promise.resolve(location);
    }

    return getPlayerVersion()
        .then(ver => Promise.resolve(location + "-" + ver));
}

function getSessionPlayerFolder() {

    const cliLocation = getCliLocation();

    return path.resolve(cliLocation, 'testim-bin')
}

function getPlayerDestination() {

    const testimAppData = getSessionPlayerFolder();

    const playerDestination = path.resolve(testimAppData, 'sessionPlayer.zip');

    return playerDestination;
}

function preparePlayer(location, canary) {
    logger.info("prepare player", { location: location, canary: canary });
    const playerFileName = getPlayerDestination();
    return localRunnerCache.memoize(
        () => getPlayerLocation(location, canary)
        .then(loc => getSource(loc, playerFileName))
        .then(() => unzipFile(playerFileName, getSessionPlayerFolder()))
        .then(() => ({})), 'preparePlayer', MSEC_IN_HALF_DAY, [location, canary]
    )();
}