boiler-task-karma/dist/karma-config.js

Build Boilerplate Static Templating

'use strict';

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

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

exports.default = function (config) {
  var _karmaConfig$files;

  const bsConfig = config.bsConfig;
  const local = config.local;
  const coverage = config.coverage;
  const desktop = config.desktop;
  const environment = config.environment;
  const file = config.file;
  const karma = config.karma;
  const mobile = config.mobile;
  var _config$pkg = config.pkg;
  const pkg = _config$pkg === undefined ? {} : _config$pkg;
  const sources = config.sources;
  const utils = config.utils;
  const transformArray = _boilerUtils2.default.transformArray;
  const isDev = environment.isDev;
  const isHfa = environment.isHfa;
  const branch = environment.branch;
  const addbase = utils.addbase;
  const customBrowsers = karma.browsers;
  const customDevices = karma.devices;
  const parentMocks = karma.mocks;

  const testPath = addbase(sources.testDir, `config/karma-${ coverage ? 'coverage' : 'index' }.js`);
  const bsBrowsers = _lodash2.default.isPlainObject(customBrowsers) ? (0, _lodash.assign)({}, _browsers2.default, customBrowsers) : _browsers2.default;
  const bsDevices = _lodash2.default.isPlainObject(customDevices) ? (0, _lodash.assign)({}, _devices2.default, customDevices) : _devices2.default;
  const customLaunchers = (0, _lodash.assign)({}, bsBrowsers, bsDevices);
  let preprocessors = {};
  let ENV, runnerData;

  if (isDev) {
    preprocessors[testPath] = ['webpack', 'sourcemap'];
    ENV = 'test';
  } else {
    ENV = 'ci';
    preprocessors[testPath] = ['webpack'];
  }

  const webpackConfig = (0, _boilerConfigWebpack2.default)((0, _lodash.assign)({}, config, { ENV, file }));

  const envConfigs = {
    test: {
      autoWatch: true,
      singleRun: false,
      reporters: ['spec'],
      coverageReporter: {
        reporters: [{ type: 'lcov', dir: 'coverage/', subdir: '.' }, { type: 'json', dir: 'coverage/', subdir: '.' }, { type: 'text-summary' }]
      }
    },
    ci: {
      reporters: local ? ['spec'] : ['dots'],

      coverageReporter: {
        reporters: [{ type: 'cobertura', dir: 'coverage/', subdir: '.', file: 'cobertura.xml' }, { type: 'text-summary' }]
      }
    }
  };

  const localDevices = ['chrome', 'firefox', 'safari'];
  const multiDevice = desktop && mobile;
  const nonLocalDevice = _lodash2.default.isArray(desktop) && desktop.filter(device => localDevices.filter(check => new RegExp(check, 'i').test(device)).length === 0);

  if (ENV === 'ci' || multiDevice || nonLocalDevice.length > 0) {
    const name = pkg.name;
    const version = pkg.version;
    const BROWSERSTACK_API = bsConfig.BROWSERSTACK_API;
    const BROWSERSTACK_USERNAME = bsConfig.BROWSERSTACK_USERNAME;

    const filterDevices = (0, _filterDevices2.default)({ bsBrowsers, bsDevices });
    const browsers = filterDevices({ desktop, mobile });
    const bsNames = browsers.map(key => {
      var _customLaunchers$key = customLaunchers[key];
      const device = _customLaunchers$key.device;
      const browser = _customLaunchers$key.browser;


      return device || browser;
    }).join(', ');

    log(`Starting Karma integration tests for: ${ magenta(bsNames) }`);

    runnerData = {
      autoWatch: false,
      singleRun: true,
      captureTimeout: 3e5,
      browserNoActivityTimeout: 3e5,
      browserDisconnectTimeout: 3e5,
      browserDisconnectTolerance: 3,

      browserStack: {
        username: BROWSERSTACK_USERNAME,
        accessKey: BROWSERSTACK_API,
        project: `v${ version } [${ branch || 'local' }:integration]`,
        build: name,
        name: bsNames
      },
      customLaunchers,
      browsers
    };
  } else {
    runnerData = {
      browsers: _lodash2.default.isArray(desktop) ? desktop.map(_lodash2.default.capitalize) : ['Chrome']
    };
  }

  const envConfig = envConfigs[ENV];

  const karmaConfig = (0, _lodash.merge)({}, envConfig, runnerData, {
    basePath: process.cwd(),
    frameworks: ['mocha', 'sinon'],
    files: ['http://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js', testPath],
    preprocessors,
    client: {
      captureConsole: false,
      mocha: {
        ui: 'bdd',
        timeout: 10000
      }
    },
    webpack: webpackConfig,
    webpackMiddleware: {
      noInfo: true
    }
  });

  if (coverage) {
    karmaConfig.reporters.push('coverage');
  }

  const baseMocks = [_path2.default.join(__dirname, 'analytics-mocks.js')];
  const normalizedMocks = transformArray(parentMocks, _lodash2.default.isString);
  const mocks = _lodash2.default.union(baseMocks, normalizedMocks);

  (_karmaConfig$files = karmaConfig.files).unshift.apply(_karmaConfig$files, (0, _toConsumableArray3.default)(transformArray(parentMocks)));

  if (isHfa) {
    var _karmaConfig$files2;

    (_karmaConfig$files2 = karmaConfig.files).unshift.apply(_karmaConfig$files2, (0, _toConsumableArray3.default)(mocks));
  } else {
    var _karmaConfig$files3;

    (_karmaConfig$files3 = karmaConfig.files).unshift.apply(_karmaConfig$files3, (0, _toConsumableArray3.default)(normalizedMocks));
  }

  return karmaConfig;
};

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _gulpUtil = require('gulp-util');

var _gulpUtil2 = _interopRequireDefault(_gulpUtil);

var _boilerConfigWebpack = require('boiler-config-webpack');

var _boilerConfigWebpack2 = _interopRequireDefault(_boilerConfigWebpack);

var _boilerUtils = require('boiler-utils');

var _boilerUtils2 = _interopRequireDefault(_boilerUtils);

var _filterDevices = require('./filter-devices');

var _filterDevices2 = _interopRequireDefault(_filterDevices);

var _browsers = require('./browser-stack/browsers');

var _browsers2 = _interopRequireDefault(_browsers);

var _devices = require('./browser-stack/devices.js');

var _devices2 = _interopRequireDefault(_devices);

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

const colors = _gulpUtil2.default.colors;
const log = _gulpUtil2.default.log;
const magenta = colors.magenta;
module.exports = exports['default'];