webdriverio-automation/node_modules/devtools/build/launcher.js

WebdriverIO-Automation android ios project

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = launch;

var _chromeLauncher = require("chrome-launcher");

var _puppeteerCore = _interopRequireDefault(require("puppeteer-core"));

var _logger = _interopRequireDefault(require("@wdio/logger"));

var _finder = _interopRequireDefault(require("./finder"));

var _utils = require("./utils");

var _constants = require("./constants");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const log = (0, _logger.default)('devtools');
const DEVICE_NAMES = Object.values(_puppeteerCore.default.devices).map(device => device.name);

async function launchChrome(capabilities) {
  if (!capabilities[_constants.VENDOR_PREFIX.chrome]) {
    capabilities[_constants.VENDOR_PREFIX.chrome] = {};
  }

  const chromeOptions = capabilities[_constants.VENDOR_PREFIX.chrome];
  const mobileEmulation = chromeOptions.mobileEmulation || {};
  const ignoreDefaultArgs = capabilities.ignoreDefaultArgs;

  if (typeof mobileEmulation.deviceName === 'string') {
    const deviceProperties = Object.values(_puppeteerCore.default.devices).find(device => device.name === mobileEmulation.deviceName);

    if (!deviceProperties) {
      throw new Error(`Unknown device name "${mobileEmulation.deviceName}", available: ${DEVICE_NAMES.join(', ')}`);
    }

    mobileEmulation.userAgent = deviceProperties.userAgent;
    mobileEmulation.deviceMetrics = {
      width: deviceProperties.viewport.width,
      height: deviceProperties.viewport.height,
      pixelRatio: deviceProperties.viewport.deviceScaleFactor
    };
  }

  const defaultFlags = Array.isArray(ignoreDefaultArgs) ? _constants.DEFAULT_FLAGS.filter(flag => !ignoreDefaultArgs.includes(flag)) : !ignoreDefaultArgs ? _constants.DEFAULT_FLAGS : [];
  const deviceMetrics = mobileEmulation.deviceMetrics || {};
  const chromeFlags = [...defaultFlags, ...[`--window-position=${_constants.DEFAULT_X_POSITION},${_constants.DEFAULT_Y_POSITION}`, `--window-size=${_constants.DEFAULT_WIDTH},${_constants.DEFAULT_HEIGHT}`], ...(chromeOptions.headless ? ['--headless', '--no-sandbox'] : []), ...(chromeOptions.args || [])];

  if (typeof deviceMetrics.pixelRatio === 'number') {
    chromeFlags.push(`--device-scale-factor=${deviceMetrics.pixelRatio}`);
  }

  if (typeof mobileEmulation.userAgent === 'string') {
    chromeFlags.push(`--user-agent=${mobileEmulation.userAgent}`);
  }

  log.info(`Launch Google Chrome with flags: ${chromeFlags.join(' ')}`);
  const chrome = await (0, _chromeLauncher.launch)({
    chromePath: chromeOptions.binary,
    ignoreDefaultArgs,
    chromeFlags
  });
  log.info(`Connect Puppeteer with browser on port ${chrome.port}`);
  const browser = await _puppeteerCore.default.connect(_objectSpread(_objectSpread({}, chromeOptions), {}, {
    browserURL: `http://localhost:${chrome.port}`,
    defaultViewport: null
  }));
  const pages = await (0, _utils.getPages)(browser);

  for (const page of pages.slice(0, -1)) {
    if (page.url() === 'about:blank') {
      await page.close();
    }
  }

  if (deviceMetrics.width && deviceMetrics.height) {
    await pages[0].setViewport(deviceMetrics);
  }

  return browser;
}

function launchBrowser(capabilities, product) {
  const vendorCapKey = _constants.VENDOR_PREFIX[product];
  const ignoreDefaultArgs = capabilities.ignoreDefaultArgs;

  if (!capabilities[vendorCapKey]) {
    capabilities[vendorCapKey] = {};
  }

  const executablePath = capabilities[vendorCapKey].binary || _finder.default[product][process.platform]()[0];

  const puppeteerOptions = Object.assign({
    product,
    executablePath,
    ignoreDefaultArgs,
    headless: Boolean(capabilities[vendorCapKey].headless),
    defaultViewport: {
      width: _constants.DEFAULT_WIDTH,
      height: _constants.DEFAULT_HEIGHT
    }
  }, capabilities[vendorCapKey] || {});

  if (!executablePath) {
    throw new Error('Couldn\'t find executable for browser');
  } else if (product === _constants.BROWSER_TYPE.firefox && !executablePath.toLowerCase().includes(_constants.CHANNEL_FIREFOX_NIGHTLY)) {
    throw new Error(_constants.BROWSER_ERROR_MESSAGES.firefoxNightly);
  }

  log.info(`Launch ${executablePath} with config: ${JSON.stringify(puppeteerOptions)}`);
  return _puppeteerCore.default.launch(puppeteerOptions);
}

function launch(capabilities) {
  const browserName = capabilities.browserName.toLowerCase();

  if (_constants.CHROME_NAMES.includes(browserName)) {
    return launchChrome(capabilities);
  }

  if (_constants.FIREFOX_NAMES.includes(browserName)) {
    return launchBrowser(capabilities, _constants.BROWSER_TYPE.firefox);
  }

  if (_constants.EDGE_NAMES.includes(browserName)) {
    return launchBrowser(capabilities, _constants.BROWSER_TYPE.edge);
  }

  throw new Error(`Couldn't identify browserName ${browserName}`);
}