webdriverio-automation/node_modules/@wdio/cli/build/commands/config.js

WebdriverIO-Automation android ios project

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.handler = handler;
exports.runConfig = exports.builder = exports.cmdArgs = exports.desc = exports.command = void 0;

var _path = _interopRequireDefault(require("path"));

var _util = _interopRequireDefault(require("util"));

var _yarnInstall = _interopRequireDefault(require("yarn-install"));

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

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

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 command = 'config';
exports.command = command;
const desc = 'Initialize WebdriverIO and setup configuration in your current project.';
exports.desc = desc;
const cmdArgs = {
  yarn: {
    type: 'boolean',
    desc: 'Install packages via yarn package manager.',
    default: (0, _utils.hasFile)('yarn.lock')
  },
  yes: {
    alias: 'y',
    desc: 'will fill in all config defaults without prompting',
    type: 'boolean',
    default: false
  }
};
exports.cmdArgs = cmdArgs;

const builder = yargs => {
  return yargs.options(cmdArgs).epilogue(_constants.CLI_EPILOGUE).help();
};

exports.builder = builder;

const runConfig = async function (useYarn, yes, exit) {
  console.log(_constants.CONFIG_HELPER_INTRO);
  const answers = await (0, _utils.getAnswers)(yes);
  const packageAnswers = ['reporters', 'runner', 'services', 'framework'];
  Object.keys(answers).forEach(key => {
    if (packageAnswers.includes(key)) {
      if (Array.isArray(answers[key])) {
        answers[key] = answers[key].map(answer => (0, _utils.convertPackageHashToObject)(answer));
      } else {
        answers[key] = (0, _utils.convertPackageHashToObject)(answers[key]);
      }
    }
  });
  const packagesToInstall = [answers.runner && answers.runner.package || '@wdio/local-runner', answers.framework.package, ...answers.reporters.map(reporter => reporter.package), ...answers.services.map(service => service.package)];
  const syncExecution = answers.executionMode === 'sync';

  if (syncExecution) {
    packagesToInstall.push('@wdio/sync');
  }

  (0, _utils.addServiceDeps)(answers.services, packagesToInstall);
  console.log('\nInstalling wdio packages:\n-', packagesToInstall.join('\n- '));
  const result = (0, _yarnInstall.default)({
    deps: packagesToInstall,
    dev: true,
    respectNpm5: !useYarn
  });

  if (result.status !== 0) {
    throw new Error(result.stderr);
  }

  console.log('\nPackages installed successfully, creating configuration file...');
  const defaultRunner = _constants.SUPPORTED_PACKAGES.runner[0].name;

  const destSpecRootPath = _path.default.join(process.cwd(), _path.default.dirname(answers.specs || '').replace(/\*\*$/, ''));

  const destStepRootPath = _path.default.join(process.cwd(), _path.default.dirname(answers.stepDefinitions || ''));

  const destPageObjectRootPath = answers.usePageObjects ? _path.default.join(process.cwd(), _path.default.dirname(answers.pages || '').replace(/\*\*$/, '')) : '';
  const relativePath = answers.generateTestFiles && answers.usePageObjects ? !(answers.framework === 'cucumber') ? _path.default.relative(destSpecRootPath, destPageObjectRootPath) : _path.default.relative(destStepRootPath, destPageObjectRootPath) : '';

  const parsedAnswers = _objectSpread(_objectSpread({}, answers), {}, {
    runner: answers.runner && answers.runner.short || defaultRunner,
    framework: answers.framework.short,
    reporters: answers.reporters.map(({
      short
    }) => short),
    services: answers.services.map(({
      short
    }) => short),
    packagesToInstall,
    isUsingTypeScript: answers.isUsingCompiler === _constants.COMPILER_OPTIONS.ts,
    isUsingBabel: answers.isUsingCompiler === _constants.COMPILER_OPTIONS.babel,
    isSync: syncExecution,
    _async: syncExecution ? '' : 'async ',
    _await: syncExecution ? '' : 'await ',
    destSpecRootPath: destSpecRootPath,
    destPageObjectRootPath: destPageObjectRootPath,
    relativePath: relativePath
  });

  try {
    await (0, _utils.renderConfigurationFile)(parsedAnswers);

    if (answers.generateTestFiles) {
      console.log('\nConfig file installed successfully, creating test files...');
      await (0, _utils.generateTestFiles)(parsedAnswers);
    }
  } catch (e) {
    console.error(`Couldn't write config file: ${e.stack}`);
    return !process.env.JEST_WORKER_ID && process.exit(1);
  }

  if (answers.isUsingCompiler === _constants.COMPILER_OPTIONS.ts) {
    const wdioTypes = syncExecution ? '@wdio/sync' : 'webdriverio';
    const tsPkgs = `"${[wdioTypes, answers.framework.package, ...answers.services.map(service => service.package).filter(service => service.startsWith('@wdio'))].join('", "')}"`;
    console.log(_util.default.format(_constants.TS_COMPILER_INSTRUCTIONS, tsPkgs));
  }

  console.log(_constants.CONFIG_HELPER_SUCCESS_MESSAGE);

  if (exit && !process.env.JEST_WORKER_ID) {
    process.exit(0);
  }
};

exports.runConfig = runConfig;

async function handler(argv) {
  try {
    await runConfig(argv.yarn, argv.yes);
  } catch (error) {
    throw new Error(`something went wrong during setup: ${error.stack.slice(7)}`);
  }
}