@wdio/config 6.4.6 → 6.7.3

package/build/constants.d.ts

@@ -0,0 +1,57 @@
+export function DEFAULT_CONFIGS(): {
+    specs: never[];
+    suites: {};
+    exclude: never[];
+    outputDir: undefined;
+    logLevel: string;
+    logLevels: {};
+    excludeDriverLogs: never[];
+    bail: number;
+    waitforInterval: number;
+    waitforTimeout: number;
+    framework: string;
+    reporters: never[];
+    services: never[];
+    maxInstances: number;
+    maxInstancesPerCapability: number;
+    filesToWatch: never[];
+    connectionRetryTimeout: number;
+    connectionRetryCount: number;
+    execArgv: never[];
+    runnerEnv: {};
+    runner: string;
+    mochaOpts: {
+        timeout: number;
+    };
+    jasmineNodeOpts: {
+        defaultTimeoutInterval: number;
+    };
+    cucumberOpts: {
+        timeout: number;
+    };
+    onPrepare: never[];
+    onWorkerStart: never[];
+    before: never[];
+    beforeSession: never[];
+    beforeSuite: never[];
+    beforeHook: never[];
+    beforeTest: never[];
+    beforeCommand: never[];
+    afterCommand: never[];
+    afterTest: never[];
+    afterHook: never[];
+    afterSuite: never[];
+    afterSession: never[];
+    after: never[];
+    onComplete: never[];
+    onReload: never[];
+    beforeFeature: never[];
+    beforeScenario: never[];
+    beforeStep: never[];
+    afterStep: never[];
+    afterScenario: never[];
+    afterFeature: never[];
+};
+export const SUPPORTED_HOOKS: string[];
+export const SUPPORTED_FILE_EXTENSIONS: string[];
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.js"],"names":[],"mappings":"AAIO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEL;AAEF,uCAKC;AAED,iDAEC"}

package/build/constants.js

@@ -1,68 +1,67 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_FILE_EXTENSIONS = exports.SUPPORTED_HOOKS = exports.DEFAULT_CONFIGS = void 0;
 const DEFAULT_TIMEOUT = 10000;
-
-const DEFAULT_CONFIGS = () => ({
-  specs: [],
-  suites: {},
-  exclude: [],
-  outputDir: undefined,
-  logLevel: 'info',
-  logLevels: {},
-  excludeDriverLogs: [],
-  bail: 0,
-  waitforInterval: 500,
-  waitforTimeout: 5000,
-  framework: 'mocha',
-  reporters: [],
-  services: [],
-  maxInstances: 100,
-  maxInstancesPerCapability: 100,
-  filesToWatch: [],
-  connectionRetryTimeout: 120000,
-  connectionRetryCount: 3,
-  execArgv: [],
-  runnerEnv: {},
-  runner: 'local',
-  mochaOpts: {
-    timeout: DEFAULT_TIMEOUT
-  },
-  jasmineNodeOpts: {
-    defaultTimeoutInterval: DEFAULT_TIMEOUT
-  },
-  cucumberOpts: {
-    timeout: DEFAULT_TIMEOUT
-  },
-  onPrepare: [],
-  onWorkerStart: [],
-  before: [],
-  beforeSession: [],
-  beforeSuite: [],
-  beforeHook: [],
-  beforeTest: [],
-  beforeCommand: [],
-  afterCommand: [],
-  afterTest: [],
-  afterHook: [],
-  afterSuite: [],
-  afterSession: [],
-  after: [],
-  onComplete: [],
-  onReload: [],
-  beforeFeature: [],
-  beforeScenario: [],
-  beforeStep: [],
-  afterStep: [],
-  afterScenario: [],
-  afterFeature: []
+exports.DEFAULT_CONFIGS = () => ({
+    specs: [],
+    suites: {},
+    exclude: [],
+    outputDir: undefined,
+    logLevel: 'info',
+    logLevels: {},
+    excludeDriverLogs: [],
+    bail: 0,
+    waitforInterval: 500,
+    waitforTimeout: 5000,
+    framework: 'mocha',
+    reporters: [],
+    services: [],
+    maxInstances: 100,
+    maxInstancesPerCapability: 100,
+    filesToWatch: [],
+    connectionRetryTimeout: 120000,
+    connectionRetryCount: 3,
+    execArgv: [],
+    runnerEnv: {},
+    runner: 'local',
+    mochaOpts: {
+        timeout: DEFAULT_TIMEOUT
+    },
+    jasmineNodeOpts: {
+        defaultTimeoutInterval: DEFAULT_TIMEOUT
+    },
+    cucumberOpts: {
+        timeout: DEFAULT_TIMEOUT
+    },
+    onPrepare: [],
+    onWorkerStart: [],
+    before: [],
+    beforeSession: [],
+    beforeSuite: [],
+    beforeHook: [],
+    beforeTest: [],
+    beforeCommand: [],
+    afterCommand: [],
+    afterTest: [],
+    afterHook: [],
+    afterSuite: [],
+    afterSession: [],
+    after: [],
+    onComplete: [],
+    onReload: [],
+    beforeFeature: [],
+    beforeScenario: [],
+    beforeStep: [],
+    afterStep: [],
+    afterScenario: [],
+    afterFeature: [],
 });
-
-exports.DEFAULT_CONFIGS = DEFAULT_CONFIGS;
-const SUPPORTED_HOOKS = ['before', 'beforeSession', 'beforeSuite', 'beforeHook', 'beforeTest', 'beforeCommand', 'afterCommand', 'afterTest', 'afterHook', 'afterSuite', 'afterSession', 'after', 'beforeFeature', 'beforeScenario', 'beforeStep', 'afterStep', 'afterScenario', 'afterFeature', 'onReload', 'onPrepare', 'onWorkerStart', 'onComplete'];
-exports.SUPPORTED_HOOKS = SUPPORTED_HOOKS;
-const SUPPORTED_FILE_EXTENSIONS = ['.js', '.mjs', '.es6', '.ts', '.feature', '.coffee', '.cjs'];
-exports.SUPPORTED_FILE_EXTENSIONS = SUPPORTED_FILE_EXTENSIONS;
+exports.SUPPORTED_HOOKS = [
+    'before', 'beforeSession', 'beforeSuite', 'beforeHook', 'beforeTest', 'beforeCommand',
+    'afterCommand', 'afterTest', 'afterHook', 'afterSuite', 'afterSession', 'after',
+    'beforeFeature', 'beforeScenario', 'beforeStep', 'afterStep', 'afterScenario', 'afterFeature',
+    'onReload', 'onPrepare', 'onWorkerStart', 'onComplete'
+];
+exports.SUPPORTED_FILE_EXTENSIONS = [
+    '.js', '.mjs', '.es6', '.ts', '.feature', '.coffee', '.cjs'
+];

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import { validateConfig } from "./utils";
+import { getSauceEndpoint } from "./utils";
+import { detectBackend } from "./utils";
+import { isCloudCapability } from "./utils";
+import ConfigParser from "./lib/ConfigParser";
+import { DEFAULT_CONFIGS } from "./constants";
+export { validateConfig, getSauceEndpoint, detectBackend, isCloudCapability, ConfigParser, DEFAULT_CONFIGS };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/build/index.js

@@ -1,43 +1,15 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "ConfigParser", {
-  enumerable: true,
-  get: function () {
-    return _ConfigParser.default;
-  }
-});
-Object.defineProperty(exports, "validateConfig", {
-  enumerable: true,
-  get: function () {
-    return _utils.validateConfig;
-  }
-});
-Object.defineProperty(exports, "getSauceEndpoint", {
-  enumerable: true,
-  get: function () {
-    return _utils.getSauceEndpoint;
-  }
-});
-Object.defineProperty(exports, "detectBackend", {
-  enumerable: true,
-  get: function () {
-    return _utils.detectBackend;
-  }
-});
-Object.defineProperty(exports, "DEFAULT_CONFIGS", {
-  enumerable: true,
-  get: function () {
-    return _constants.DEFAULT_CONFIGS;
-  }
-});
-
-var _ConfigParser = _interopRequireDefault(require("./lib/ConfigParser"));
-
-var _utils = require("./utils");
-
-var _constants = require("./constants");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIGS = exports.ConfigParser = exports.isCloudCapability = exports.detectBackend = exports.getSauceEndpoint = exports.validateConfig = void 0;
+const ConfigParser_1 = __importDefault(require("./lib/ConfigParser"));
+exports.ConfigParser = ConfigParser_1.default;
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return utils_1.validateConfig; } });
+Object.defineProperty(exports, "getSauceEndpoint", { enumerable: true, get: function () { return utils_1.getSauceEndpoint; } });
+Object.defineProperty(exports, "detectBackend", { enumerable: true, get: function () { return utils_1.detectBackend; } });
+Object.defineProperty(exports, "isCloudCapability", { enumerable: true, get: function () { return utils_1.isCloudCapability; } });
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_CONFIGS", { enumerable: true, get: function () { return constants_1.DEFAULT_CONFIGS; } });

package/build/lib/ConfigParser.d.ts

@@ -0,0 +1,119 @@
+export default class ConfigParser {
+    static getFilePaths(patterns: any, omitWarnings: any): string[];
+    _config: {
+        specs: never[];
+        suites: {};
+        exclude: never[];
+        outputDir: undefined;
+        logLevel: string;
+        logLevels: {};
+        excludeDriverLogs: never[];
+        bail: number;
+        waitforInterval: number;
+        waitforTimeout: number;
+        framework: string;
+        reporters: never[];
+        services: never[];
+        maxInstances: number;
+        maxInstancesPerCapability: number;
+        filesToWatch: never[];
+        connectionRetryTimeout: number;
+        connectionRetryCount: number;
+        execArgv: never[];
+        runnerEnv: {};
+        runner: string;
+        mochaOpts: {
+            timeout: number;
+        };
+        jasmineNodeOpts: {
+            defaultTimeoutInterval: number;
+        };
+        cucumberOpts: {
+            timeout: number;
+        };
+        onPrepare: never[];
+        onWorkerStart: never[];
+        before: never[];
+        beforeSession: never[];
+        beforeSuite: never[];
+        beforeHook: never[];
+        beforeTest: never[];
+        beforeCommand: never[];
+        afterCommand: never[];
+        afterTest: never[];
+        afterHook: never[];
+        afterSuite: never[];
+        afterSession: never[];
+        after: never[];
+        onComplete: never[];
+        onReload: never[];
+        beforeFeature: never[];
+        beforeScenario: never[];
+        beforeStep: never[];
+        afterStep: never[];
+        afterScenario: never[];
+        afterFeature: never[];
+    };
+    _capabilities: any[];
+    addConfigFile(filename: string): void;
+    merge(object?: Object): void;
+    addService(service: Object): void;
+    getSpecs(capSpecs: any, capExclude: any): string[];
+    setFilePathToFilterOptions(cliArgFileList: string, config: Object): string[];
+    getConfig(): {
+        specs: never[];
+        suites: {};
+        exclude: never[];
+        outputDir: undefined;
+        logLevel: string;
+        logLevels: {};
+        excludeDriverLogs: never[];
+        bail: number;
+        waitforInterval: number;
+        waitforTimeout: number;
+        framework: string;
+        reporters: never[];
+        services: never[];
+        maxInstances: number;
+        maxInstancesPerCapability: number;
+        filesToWatch: never[];
+        connectionRetryTimeout: number;
+        connectionRetryCount: number;
+        execArgv: never[];
+        runnerEnv: {};
+        runner: string;
+        mochaOpts: {
+            timeout: number;
+        };
+        jasmineNodeOpts: {
+            defaultTimeoutInterval: number;
+        };
+        cucumberOpts: {
+            timeout: number;
+        };
+        onPrepare: never[];
+        onWorkerStart: never[];
+        before: never[];
+        beforeSession: never[];
+        beforeSuite: never[];
+        beforeHook: never[];
+        beforeTest: never[];
+        beforeCommand: never[];
+        afterCommand: never[];
+        afterTest: never[];
+        afterHook: never[];
+        afterSuite: never[];
+        afterSession: never[];
+        after: never[];
+        onComplete: never[];
+        onReload: never[];
+        beforeFeature: never[];
+        beforeScenario: never[];
+        beforeStep: never[];
+        afterStep: never[];
+        afterScenario: never[];
+        afterFeature: never[];
+    };
+    getCapabilities(i: any): any;
+}
+//# sourceMappingURL=ConfigParser.d.ts.map

package/build/lib/ConfigParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigParser.d.ts","sourceRoot":"","sources":["../../src/lib/ConfigParser.js"],"names":[],"mappings":"AAcA;IAsQI,uDAFY,QAAQ,CAkCnB;IApSG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgC;IAEhC,qBAAuB;IAO3B,sCAoDC;IAMD,eAFY,MAAM,QA2DjB;IAMD,oBAFW,MAAM,QAkBhB;IAKD,mDAkDC;IAWD,2DAJY,MAAM,GAEN,QAAQ,CAwBnB;IAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEC;IAKD,6BAMC;CAyCJ"}

package/build/lib/ConfigParser.js

@@ -1,237 +1,186 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _fs = _interopRequireDefault(require("fs"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _glob = _interopRequireDefault(require("glob"));
-
-var _deepmerge = _interopRequireDefault(require("deepmerge"));
-
-var _logger = _interopRequireDefault(require("@wdio/logger"));
-
-var _utils = require("../utils");
-
-var _constants = require("../constants");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const log = (0, _logger.default)('@wdio/config:ConfigParser');
-const MERGE_OPTIONS = {
-  clone: false
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = __importDefault(require("glob"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const log = logger_1.default('@wdio/config:ConfigParser');
+const MERGE_OPTIONS = { clone: false };
 class ConfigParser {
-  constructor() {
-    this._config = (0, _constants.DEFAULT_CONFIGS)();
-    this._capabilities = [];
-  }
-
-  addConfigFile(filename) {
-    if (typeof filename !== 'string') {
-      throw new Error('addConfigFile requires filepath');
+    constructor() {
+        this._config = constants_1.DEFAULT_CONFIGS();
+        this._capabilities = [];
     }
-
-    const filePath = _path.default.resolve(process.cwd(), filename);
-
-    try {
-      const fileConfig = (0, _deepmerge.default)(require(filePath).config, {}, MERGE_OPTIONS);
-      const defaultTo = Array.isArray(this._capabilities) ? [] : {};
-      this._capabilities = (0, _deepmerge.default)(this._capabilities, fileConfig.capabilities || defaultTo, MERGE_OPTIONS);
-      delete fileConfig.capabilities;
-      this.addService(fileConfig);
-
-      for (let hookName of _constants.SUPPORTED_HOOKS) {
-        delete fileConfig[hookName];
-      }
-
-      this._config = (0, _deepmerge.default)(this._config, fileConfig, MERGE_OPTIONS);
-
-      const isRDC = Array.isArray(this._capabilities) && this._capabilities.some(capability => 'testobject_api_key' in capability);
-
-      this._config = (0, _deepmerge.default)((0, _utils.detectBackend)(this._config, isRDC), this._config, MERGE_OPTIONS);
-      delete this._config.watch;
-    } catch (e) {
-      log.error(`Failed loading configuration file: ${filePath}:`, e.message);
-      throw e;
-    }
-  }
-
-  merge(object = {}) {
-    const spec = Array.isArray(object.spec) ? object.spec : [];
-    const exclude = Array.isArray(object.exclude) ? object.exclude : [];
-    this._config = (0, _deepmerge.default)(this._config, object, MERGE_OPTIONS);
-
-    if (object.specs && object.specs.length > 0) {
-      this._config.specs = object.specs;
-    } else if (object.exclude && object.exclude.length > 0) {
-      this._config.exclude = object.exclude;
-    }
-
-    this._capabilities = (0, _utils.validObjectOrArray)(this._config.capabilities) ? this._config.capabilities : this._capabilities;
-
-    if (this._config.spec && (0, _utils.isCucumberFeatureWithLineNumber)(this._config.spec)) {
-      this._config.cucumberFeaturesWithLineNumbers = Array.isArray(this._config.spec) ? [...this._config.spec] : [this._config.spec];
-    }
-
-    if (spec.length > 0) {
-      this._config.specs = [...this.setFilePathToFilterOptions(spec, this._config.specs)];
-    }
-
-    if (exclude.length > 0) {
-      this._config.exclude = [...this.setFilePathToFilterOptions(exclude, this._config.exclude)];
-    }
-
-    let defaultBackend = (0, _utils.detectBackend)({});
-
-    if (this._config.protocol === defaultBackend.protocol && this._config.hostname === defaultBackend.hostname && this._config.port === defaultBackend.port && this._config.path === defaultBackend.path) {
-      delete this._config.protocol;
-      delete this._config.hostname;
-      delete this._config.port;
-      delete this._config.path;
-    }
-
-    this._config = (0, _deepmerge.default)((0, _utils.detectBackend)(this._config), this._config, MERGE_OPTIONS);
-  }
-
-  addService(service) {
-    for (let hookName of _constants.SUPPORTED_HOOKS) {
-      if (!service[hookName]) {
-        continue;
-      }
-
-      if (typeof service[hookName] === 'function') {
-        this._config[hookName].push(service[hookName].bind(service));
-      } else if (Array.isArray(service[hookName])) {
-        for (let hook of service[hookName]) {
-          if (typeof hook === 'function') {
-            this._config[hookName].push(hook.bind(service));
-          }
-        }
-      }
-    }
-  }
-
-  getSpecs(capSpecs, capExclude) {
-    let specs = ConfigParser.getFilePaths(this._config.specs);
-    let spec = Array.isArray(this._config.spec) ? this._config.spec : [];
-    let exclude = ConfigParser.getFilePaths(this._config.exclude);
-    let suites = Array.isArray(this._config.suite) ? this._config.suite : [];
-
-    if (suites.length > 0) {
-      let suiteSpecs = [];
-
-      for (let suiteName of suites) {
-        let suite = this._config.suites[suiteName];
-
-        if (suite && Array.isArray(suite)) {
-          suiteSpecs = suiteSpecs.concat(ConfigParser.getFilePaths(suite));
-        }
-      }
-
-      if (suiteSpecs.length === 0) {
-        throw new Error(`The suite(s) "${suites.join('", "')}" you specified don't exist ` + 'in your config file or doesn\'t contain any files!');
-      }
-
-      let tmpSpecs = spec.length > 0 ? [...specs, ...suiteSpecs] : suiteSpecs;
-
-      if (Array.isArray(capSpecs)) {
-        tmpSpecs = ConfigParser.getFilePaths(capSpecs);
-      }
-
-      if (Array.isArray(capExclude)) {
-        exclude = ConfigParser.getFilePaths(capExclude);
-      }
-
-      specs = [...new Set(tmpSpecs)];
-      return specs.filter(spec => !exclude.includes(spec));
-    }
-
-    if (Array.isArray(capSpecs)) {
-      specs = ConfigParser.getFilePaths(capSpecs);
+    addConfigFile(filename) {
+        if (typeof filename !== 'string') {
+            throw new Error('addConfigFile requires filepath');
+        }
+        const filePath = path_1.default.resolve(process.cwd(), filename);
+        try {
+            const fileConfig = deepmerge_1.default(require(filePath).config, {}, MERGE_OPTIONS);
+            const defaultTo = Array.isArray(this._capabilities) ? [] : {};
+            this._capabilities = deepmerge_1.default(this._capabilities, fileConfig.capabilities || defaultTo, MERGE_OPTIONS);
+            delete fileConfig.capabilities;
+            this.addService(fileConfig);
+            for (let hookName of constants_1.SUPPORTED_HOOKS) {
+                delete fileConfig[hookName];
+            }
+            this._config = deepmerge_1.default(this._config, fileConfig, MERGE_OPTIONS);
+            const isRDC = Array.isArray(this._capabilities) && this._capabilities.some(capability => 'testobject_api_key' in capability);
+            this._config = deepmerge_1.default(utils_1.detectBackend(this._config, isRDC), this._config, MERGE_OPTIONS);
+            delete this._config.watch;
+        }
+        catch (e) {
+            log.error(`Failed loading configuration file: ${filePath}:`, e.message);
+            throw e;
+        }
     }
-
-    if (Array.isArray(capExclude)) {
-      exclude = ConfigParser.getFilePaths(capExclude);
+    merge(object = {}) {
+        const spec = Array.isArray(object.spec) ? object.spec : [];
+        const exclude = Array.isArray(object.exclude) ? object.exclude : [];
+        this._config = deepmerge_1.default(this._config, object, MERGE_OPTIONS);
+        if (object.specs && object.specs.length > 0) {
+            this._config.specs = object.specs;
+        }
+        else if (object.exclude && object.exclude.length > 0) {
+            this._config.exclude = object.exclude;
+        }
+        this._capabilities = utils_1.validObjectOrArray(this._config.capabilities) ? this._config.capabilities : this._capabilities;
+        if (this._config.spec && utils_1.isCucumberFeatureWithLineNumber(this._config.spec)) {
+            this._config.cucumberFeaturesWithLineNumbers = Array.isArray(this._config.spec) ? [...this._config.spec] : [this._config.spec];
+        }
+        if (spec.length > 0) {
+            this._config.specs = [...this.setFilePathToFilterOptions(spec, this._config.specs)];
+        }
+        if (exclude.length > 0) {
+            this._config.exclude = [...this.setFilePathToFilterOptions(exclude, this._config.exclude)];
+        }
+        let defaultBackend = utils_1.detectBackend({});
+        if ((this._config.protocol === defaultBackend.protocol) &&
+            (this._config.hostname === defaultBackend.hostname) &&
+            (this._config.port === defaultBackend.port) &&
+            (this._config.path === defaultBackend.path)) {
+            delete this._config.protocol;
+            delete this._config.hostname;
+            delete this._config.port;
+            delete this._config.path;
+        }
+        this._config = deepmerge_1.default(utils_1.detectBackend(this._config), this._config, MERGE_OPTIONS);
+    }
+    addService(service) {
+        for (let hookName of constants_1.SUPPORTED_HOOKS) {
+            if (!service[hookName]) {
+                continue;
+            }
+            if (typeof service[hookName] === 'function') {
+                this._config[hookName].push(service[hookName].bind(service));
+            }
+            else if (Array.isArray(service[hookName])) {
+                for (let hook of service[hookName]) {
+                    if (typeof hook === 'function') {
+                        this._config[hookName].push(hook.bind(service));
+                    }
+                }
+            }
+        }
     }
-
-    return specs.filter(spec => !exclude.includes(spec));
-  }
-
-  setFilePathToFilterOptions(cliArgFileList, config) {
-    const filesToFilter = new Set();
-    const fileList = ConfigParser.getFilePaths(config);
-    cliArgFileList.forEach(filteredFile => {
-      filteredFile = (0, _utils.removeLineNumbers)(filteredFile);
-      let globMatchedFiles = ConfigParser.getFilePaths(_glob.default.sync(filteredFile));
-
-      if (_fs.default.existsSync(filteredFile) && _fs.default.lstatSync(filteredFile).isFile()) {
-        filesToFilter.add(_path.default.resolve(process.cwd(), filteredFile));
-      } else if (globMatchedFiles.length) {
-        globMatchedFiles.forEach(file => filesToFilter.add(file));
-      } else {
-        fileList.forEach(file => {
-          if (file.match(filteredFile)) {
-            filesToFilter.add(file);
-          }
+    getSpecs(capSpecs, capExclude) {
+        let specs = ConfigParser.getFilePaths(this._config.specs);
+        let spec = Array.isArray(this._config.spec) ? this._config.spec : [];
+        let exclude = ConfigParser.getFilePaths(this._config.exclude);
+        let suites = Array.isArray(this._config.suite) ? this._config.suite : [];
+        if (suites.length > 0) {
+            let suiteSpecs = [];
+            for (let suiteName of suites) {
+                let suite = this._config.suites[suiteName];
+                if (suite && Array.isArray(suite)) {
+                    suiteSpecs = suiteSpecs.concat(ConfigParser.getFilePaths(suite));
+                }
+            }
+            if (suiteSpecs.length === 0) {
+                throw new Error(`The suite(s) "${suites.join('", "')}" you specified don't exist ` +
+                    'in your config file or doesn\'t contain any files!');
+            }
+            let tmpSpecs = spec.length > 0 ? [...specs, ...suiteSpecs] : suiteSpecs;
+            if (Array.isArray(capSpecs)) {
+                tmpSpecs = ConfigParser.getFilePaths(capSpecs);
+            }
+            if (Array.isArray(capExclude)) {
+                exclude = ConfigParser.getFilePaths(capExclude);
+            }
+            specs = [...new Set(tmpSpecs)];
+            return specs.filter(spec => !exclude.includes(spec));
+        }
+        if (Array.isArray(capSpecs)) {
+            specs = ConfigParser.getFilePaths(capSpecs);
+        }
+        if (Array.isArray(capExclude)) {
+            exclude = ConfigParser.getFilePaths(capExclude);
+        }
+        return specs.filter(spec => !exclude.includes(spec));
+    }
+    setFilePathToFilterOptions(cliArgFileList, config) {
+        const filesToFilter = new Set();
+        const fileList = ConfigParser.getFilePaths(config);
+        cliArgFileList.forEach(filteredFile => {
+            filteredFile = utils_1.removeLineNumbers(filteredFile);
+            let globMatchedFiles = ConfigParser.getFilePaths(glob_1.default.sync(filteredFile));
+            if (fs_1.default.existsSync(filteredFile) && fs_1.default.lstatSync(filteredFile).isFile()) {
+                filesToFilter.add(path_1.default.resolve(process.cwd(), filteredFile));
+            }
+            else if (globMatchedFiles.length) {
+                globMatchedFiles.forEach(file => filesToFilter.add(file));
+            }
+            else {
+                fileList.forEach(file => {
+                    if (file.match(filteredFile)) {
+                        filesToFilter.add(file);
+                    }
+                });
+            }
         });
-      }
-    });
-
-    if (filesToFilter.size === 0) {
-      throw new Error(`spec file(s) ${cliArgFileList.join(', ')} not found`);
-    }
-
-    return filesToFilter;
-  }
-
-  getConfig() {
-    return this._config;
-  }
-
-  getCapabilities(i) {
-    if (typeof i === 'number' && this._capabilities[i]) {
-      return this._capabilities[i];
+        if (filesToFilter.size === 0) {
+            throw new Error(`spec file(s) ${cliArgFileList.join(', ')} not found`);
+        }
+        return filesToFilter;
     }
-
-    return this._capabilities;
-  }
-
-  static getFilePaths(patterns, omitWarnings) {
-    let files = [];
-
-    if (typeof patterns === 'string') {
-      patterns = (0, _utils.removeLineNumbers)(patterns);
-      patterns = [patterns];
-    } else {
-      patterns = patterns.map(pattern => (0, _utils.removeLineNumbers)(pattern));
+    getConfig() {
+        return this._config;
     }
-
-    if (!Array.isArray(patterns)) {
-      throw new Error('specs or exclude property should be an array of strings');
+    getCapabilities(i) {
+        if (typeof i === 'number' && this._capabilities[i]) {
+            return this._capabilities[i];
+        }
+        return this._capabilities;
     }
-
-    for (let pattern of patterns) {
-      let filenames = _glob.default.sync(pattern);
-
-      filenames = filenames.filter(filename => _constants.SUPPORTED_FILE_EXTENSIONS.find(ext => filename.endsWith(ext)));
-      filenames = filenames.map(filename => _path.default.isAbsolute(filename) ? _path.default.normalize(filename) : _path.default.resolve(process.cwd(), filename));
-
-      if (filenames.length === 0 && !omitWarnings) {
-        log.warn('pattern', pattern, 'did not match any file');
-      }
-
-      files = (0, _deepmerge.default)(files, filenames, MERGE_OPTIONS);
+    static getFilePaths(patterns, omitWarnings) {
+        let files = [];
+        if (typeof patterns === 'string') {
+            patterns = utils_1.removeLineNumbers(patterns);
+            patterns = [patterns];
+        }
+        else {
+            patterns = patterns.map(pattern => utils_1.removeLineNumbers(pattern));
+        }
+        if (!Array.isArray(patterns)) {
+            throw new Error('specs or exclude property should be an array of strings');
+        }
+        for (let pattern of patterns) {
+            let filenames = glob_1.default.sync(pattern);
+            filenames = filenames.filter((filename) => constants_1.SUPPORTED_FILE_EXTENSIONS.find((ext) => filename.endsWith(ext)));
+            filenames = filenames.map(filename => path_1.default.isAbsolute(filename) ? path_1.default.normalize(filename) : path_1.default.resolve(process.cwd(), filename));
+            if (filenames.length === 0 && !omitWarnings) {
+                log.warn('pattern', pattern, 'did not match any file');
+            }
+            files = deepmerge_1.default(files, filenames, MERGE_OPTIONS);
+        }
+        return files;
     }
-
-    return files;
-  }
-
 }
-
-exports.default = ConfigParser;
+exports.default = ConfigParser;

package/build/utils.d.ts

@@ -0,0 +1,13 @@
+export function getSauceEndpoint(region: any, isRDC: any): string;
+export function removeLineNumbers(filePath: string): string;
+export function isCucumberFeatureWithLineNumber(spec: string | string[]): boolean;
+export function isCloudCapability(cap: any): boolean;
+export function detectBackend(options?: {}, isRDC?: boolean): {
+    protocol: any;
+    hostname: any;
+    port: any;
+    path: any;
+};
+export function validateConfig(defaults: Object, options: Object, keysToKeep?: any[]): Object;
+export function validObjectOrArray(object: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAgBA,kEAOC;AAQD,4CAHa,MAAM,GACN,MAAM,CAQlB;AAOD,sDAFW,MAAM,GAAC,MAAM,EAAE,WAKzB;AAED,qDAEC;AAKD;;;;;EAoFC;AAQD,yCAJY,MAAM,WACN,MAAM,uBACN,MAAM,CAgDjB;AArLM,yDAC2D"}

package/build/utils.js

@@ -1,154 +1,122 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSauceEndpoint = getSauceEndpoint;
-exports.removeLineNumbers = removeLineNumbers;
-exports.isCucumberFeatureWithLineNumber = isCucumberFeatureWithLineNumber;
-exports.detectBackend = detectBackend;
-exports.validateConfig = validateConfig;
-exports.validObjectOrArray = void 0;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = exports.detectBackend = exports.isCloudCapability = exports.isCucumberFeatureWithLineNumber = exports.removeLineNumbers = exports.getSauceEndpoint = exports.validObjectOrArray = void 0;
 const DEFAULT_HOSTNAME = '127.0.0.1';
 const DEFAULT_PORT = 4444;
 const DEFAULT_PROTOCOL = 'http';
 const DEFAULT_PATH = '/';
 const LEGACY_PATH = '/wd/hub';
 const REGION_MAPPING = {
-  'us': 'us-west-1.',
-  'eu': 'eu-central-1.',
-  'eu-central-1': 'eu-central-1.',
-  'us-east-1': 'us-east-1.'
+    'us': 'us-west-1.',
+    'eu': 'eu-central-1.',
+    'eu-central-1': 'eu-central-1.',
+    'us-east-1': 'us-east-1.'
 };
-
-const validObjectOrArray = object => Array.isArray(object) && object.length > 0 || typeof object === 'object' && Object.keys(object).length > 0;
-
-exports.validObjectOrArray = validObjectOrArray;
-
+exports.validObjectOrArray = (object) => (Array.isArray(object) && object.length > 0) ||
+    (typeof object === 'object' && Object.keys(object).length > 0);
 function getSauceEndpoint(region, isRDC) {
-  const shortRegion = REGION_MAPPING[region] ? region : 'us';
-
-  if (isRDC) {
-    return `${shortRegion}1.appium.testobject.com`;
-  }
-
-  return `ondemand.${REGION_MAPPING[shortRegion]}saucelabs.com`;
+    const shortRegion = REGION_MAPPING[region] ? region : 'us';
+    if (isRDC) {
+        return `${shortRegion}1.appium.testobject.com`;
+    }
+    return `ondemand.${REGION_MAPPING[shortRegion]}saucelabs.com`;
 }
-
+exports.getSauceEndpoint = getSauceEndpoint;
 function removeLineNumbers(filePath) {
-  const matcher = filePath.match(/:\d+(:\d+$|$)/);
-
-  if (matcher) {
-    filePath = filePath.substring(0, matcher.index);
-  }
-
-  return filePath;
+    const matcher = filePath.match(/:\d+(:\d+$|$)/);
+    if (matcher) {
+        filePath = filePath.substring(0, matcher.index);
+    }
+    return filePath;
 }
-
+exports.removeLineNumbers = removeLineNumbers;
 function isCucumberFeatureWithLineNumber(spec) {
-  const specs = Array.isArray(spec) ? spec : [spec];
-  return specs.some(s => s.match(/:\d+(:\d+$|$)/));
+    const specs = Array.isArray(spec) ? spec : [spec];
+    return specs.some((s) => s.match(/:\d+(:\d+$|$)/));
 }
-
-function detectBackend(options = {}, isRDC = false) {
-  let {
-    port,
-    hostname,
-    user,
-    key,
-    protocol,
-    region,
-    headless,
-    path
-  } = options;
-
-  if (typeof user === 'string' && typeof key === 'string' && key.length === 20) {
-    return {
-      protocol: protocol || 'https',
-      hostname: hostname || 'hub-cloud.browserstack.com',
-      port: port || 443,
-      path: path || LEGACY_PATH
-    };
-  }
-
-  if (typeof user === 'string' && typeof key === 'string' && key.length === 32) {
-    return {
-      protocol: protocol || 'https',
-      hostname: hostname || 'hub.testingbot.com',
-      port: port || 443,
-      path: path || LEGACY_PATH
-    };
-  }
-
-  if (typeof user === 'string' && typeof key === 'string' && key.length === 36 || typeof user === 'string' && isRDC || isRDC) {
-    const sauceRegion = headless ? 'us-east-1' : region;
-    return {
-      protocol: protocol || 'https',
-      hostname: hostname || getSauceEndpoint(sauceRegion, isRDC),
-      port: port || 443,
-      path: path || LEGACY_PATH
-    };
-  }
-
-  if ((typeof user === 'string' || typeof key === 'string') && !hostname) {
-    throw new Error('A "user" or "key" was provided but could not be connected to a ' + 'known cloud service (Sauce Labs, Browerstack or Testingbot). ' + 'Please check if given user and key properties are correct!');
-  }
-
-  if (hostname || port || protocol || path) {
-    return {
-      hostname: hostname || DEFAULT_HOSTNAME,
-      port: port || DEFAULT_PORT,
-      protocol: protocol || DEFAULT_PROTOCOL,
-      path: path || DEFAULT_PATH
-    };
-  }
-
-  return {
-    hostname,
-    port,
-    protocol,
-    path
-  };
+exports.isCucumberFeatureWithLineNumber = isCucumberFeatureWithLineNumber;
+function isCloudCapability(cap) {
+    return Boolean(cap && (cap['bstack:options'] || cap['sauce:options'] || cap['tb:options']));
 }
-
-function validateConfig(defaults, options, keysToKeep = []) {
-  const params = {};
-
-  for (const [name, expectedOption] of Object.entries(defaults)) {
-    if (typeof options[name] === 'undefined' && !expectedOption.default && expectedOption.required) {
-      throw new Error(`Required option "${name}" is missing`);
+exports.isCloudCapability = isCloudCapability;
+function detectBackend(options = {}, isRDC = false) {
+    let { port, hostname, user, key, protocol, region, headless, path } = options;
+    if (typeof user === 'string' && typeof key === 'string' && key.length === 20) {
+        return {
+            protocol: protocol || 'https',
+            hostname: hostname || 'hub-cloud.browserstack.com',
+            port: port || 443,
+            path: path || LEGACY_PATH
+        };
+    }
+    if (typeof user === 'string' && typeof key === 'string' && key.length === 32) {
+        return {
+            protocol: protocol || 'https',
+            hostname: hostname || 'hub.testingbot.com',
+            port: port || 443,
+            path: path || LEGACY_PATH
+        };
+    }
+    if ((typeof user === 'string' && typeof key === 'string' && key.length === 36) ||
+        (typeof user === 'string' && isRDC) ||
+        isRDC) {
+        const sauceRegion = headless ? 'us-east-1' : region;
+        return {
+            protocol: protocol || 'https',
+            hostname: hostname || getSauceEndpoint(sauceRegion, isRDC),
+            port: port || 443,
+            path: path || LEGACY_PATH
+        };
     }
-
-    if (typeof options[name] === 'undefined' && expectedOption.default) {
-      params[name] = expectedOption.default;
+    if ((typeof user === 'string' || typeof key === 'string') &&
+        !hostname) {
+        throw new Error('A "user" or "key" was provided but could not be connected to a ' +
+            'known cloud service (Sauce Labs, Browerstack or Testingbot). ' +
+            'Please check if given user and key properties are correct!');
     }
-
-    if (typeof options[name] !== 'undefined') {
-      if (typeof expectedOption.type === 'string' && typeof options[name] !== expectedOption.type) {
-        throw new Error(`Expected option "${name}" to be type of ${expectedOption.type} but was ${typeof options[name]}`);
-      }
-
-      if (typeof expectedOption.type === 'function') {
-        try {
-          expectedOption.type(options[name]);
-        } catch (e) {
-          throw new Error(`Type check for option "${name}" failed: ${e.message}`);
+    if (hostname || port || protocol || path) {
+        return {
+            hostname: hostname || DEFAULT_HOSTNAME,
+            port: port || DEFAULT_PORT,
+            protocol: protocol || DEFAULT_PROTOCOL,
+            path: path || DEFAULT_PATH
+        };
+    }
+    return { hostname, port, protocol, path };
+}
+exports.detectBackend = detectBackend;
+function validateConfig(defaults, options, keysToKeep = []) {
+    const params = {};
+    for (const [name, expectedOption] of Object.entries(defaults)) {
+        if (typeof options[name] === 'undefined' && !expectedOption.default && expectedOption.required) {
+            throw new Error(`Required option "${name}" is missing`);
+        }
+        if (typeof options[name] === 'undefined' && expectedOption.default) {
+            params[name] = expectedOption.default;
+        }
+        if (typeof options[name] !== 'undefined') {
+            if (typeof options[name] !== expectedOption.type) {
+                throw new Error(`Expected option "${name}" to be type of ${expectedOption.type} but was ${typeof options[name]}`);
+            }
+            if (typeof expectedOption.validate === 'function') {
+                try {
+                    expectedOption.validate(options[name]);
+                }
+                catch (e) {
+                    throw new Error(`Type check for option "${name}" failed: ${e.message}`);
+                }
+            }
+            if (expectedOption.match && !options[name].match(expectedOption.match)) {
+                throw new Error(`Option "${name}" doesn't match expected values: ${expectedOption.match}`);
+            }
+            params[name] = options[name];
         }
-      }
-
-      if (expectedOption.match && !options[name].match(expectedOption.match)) {
-        throw new Error(`Option "${name}" doesn't match expected values: ${expectedOption.match}`);
-      }
-
-      params[name] = options[name];
     }
-  }
-
-  for (const [name, option] of Object.entries(options)) {
-    if (keysToKeep.includes(name)) {
-      params[name] = option;
+    for (const [name, option] of Object.entries(options)) {
+        if (keysToKeep.includes(name)) {
+            params[name] = option;
+        }
     }
-  }
-
-  return params;
-}
+    return params;
+}
+exports.validateConfig = validateConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/config",
-  "version": "6.4.6",
+  "version": "6.7.3",
   "description": "A helper utility to parse and validate WebdriverIO options",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/master/packages/wdio-config",
@@ -9,14 +9,6 @@
   "engines": {
     "node": ">=10.0.0"
   },
-  "scripts": {
-    "build": "run-s clean compile",
-    "clean": "rimraf ./build",
-    "compile": "babel src/ -d build/ --config-file ../../babel.config.js",
-    "test": "run-s test:*",
-    "test:eslint": "eslint src test",
-    "test:unit": "jest"
-  },
   "repository": {
     "type": "git",
     "url": "git://github.com/webdriverio/webdriverio.git"
@@ -30,12 +22,12 @@
     "url": "https://github.com/webdriverio/webdriverio/issues"
   },
   "dependencies": {
-    "@wdio/logger": "6.0.16",
+    "@wdio/logger": "6.7.3",
     "deepmerge": "^4.0.0",
     "glob": "^7.1.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "df7da4b57c2887b1da3fccfac6efc6f0e9ea1ffc"
+  "gitHead": "2d72a4f1be35727342bf31b750d76eab6c8b50e9"
 }