@wdio/runner 9.0.0-alpha.78 → 9.0.0

package/build/reporter.js

@@ -1,192 +0,0 @@
-import path from 'node:path';
-import logger from '@wdio/logger';
-import { initializePlugin } from '@wdio/utils';
-const log = logger('@wdio/runner');
-const mochaAllHooks = ['"before all" hook', '"after all" hook'];
-/**
- * BaseReporter
- * responsible for initialising reporters for every testrun and propagating events
- * to all these reporters
- */
-export default class BaseReporter {
-    _config;
-    _cid;
-    caps;
-    _reporters = [];
-    listeners = [];
-    constructor(_config, _cid, caps) {
-        this._config = _config;
-        this._cid = _cid;
-        this.caps = caps;
-    }
-    async initReporters() {
-        this._reporters = await Promise.all(this._config.reporters.map(this._loadReporter.bind(this)));
-    }
-    /**
-     * emit events to all registered reporter and wdio launcer
-     *
-     * @param  {string} e       event name
-     * @param  {object} payload event payload
-     */
-    emit(e, payload) {
-        payload.cid = this._cid;
-        /**
-         * Send failure message (only once) in case of test or hook failure
-         */
-        const isTestError = e === 'test:fail';
-        const isHookError = (e === 'hook:end' &&
-            payload.error &&
-            mochaAllHooks.some(hook => payload.title.startsWith(hook)));
-        if (isTestError || isHookError) {
-            this.#emitData({
-                origin: 'reporter',
-                name: 'printFailureMessage',
-                content: payload
-            });
-        }
-        this._reporters.forEach((reporter) => reporter.emit(e, payload));
-    }
-    onMessage(listener) {
-        this.listeners.push(listener);
-    }
-    getLogFile(name) {
-        // clone the config to avoid changing original properties
-        const options = Object.assign({}, this._config);
-        let filename = `wdio-${this._cid}-${name}-reporter.log`;
-        const reporterOptions = this._config.reporters.find((reporter) => (Array.isArray(reporter) &&
-            (reporter[0] === name ||
-                typeof reporter[0] === 'function' && reporter[0].name === name)));
-        if (reporterOptions && Array.isArray(reporterOptions)) {
-            const fileformat = reporterOptions[1].outputFileFormat;
-            options.cid = this._cid;
-            options.capabilities = this.caps;
-            Object.assign(options, reporterOptions[1]);
-            if (fileformat) {
-                if (typeof fileformat !== 'function') {
-                    throw new Error('outputFileFormat must be a function');
-                }
-                filename = fileformat(options);
-            }
-        }
-        if (!options.outputDir) {
-            return;
-        }
-        return path.join(options.outputDir, filename);
-    }
-    /**
-     * return write stream object based on reporter name
-     */
-    getWriteStreamObject(reporter) {
-        return {
-            write: /* istanbul ignore next */ (content) => this.#emitData({
-                origin: 'reporter',
-                name: reporter,
-                content
-            })
-        };
-    }
-    /**
-     * emit data either through process or listener
-     */
-    #emitData(payload) {
-        if (typeof process.send === 'function') {
-            return process.send(payload);
-        }
-        this.listeners.forEach((fn) => fn(payload));
-        return true;
-    }
-    /**
-     * wait for reporter to finish synchronization, e.g. when sending data asynchronous
-     * to a server (e.g. sumo reporter)
-     */
-    waitForSync() {
-        const startTime = Date.now();
-        return new Promise((resolve, reject) => {
-            const interval = setInterval(() => {
-                const unsyncedReporter = this._reporters
-                    .filter((reporter) => !reporter.isSynchronised)
-                    .map((reporter) => reporter.constructor.name);
-                if ((Date.now() - startTime) > this._config.reporterSyncTimeout && unsyncedReporter.length) {
-                    clearInterval(interval);
-                    return reject(new Error(`Some reporters are still unsynced: ${unsyncedReporter.join(', ')}`));
-                }
-                /**
-                 * no reporter are in need to sync anymore, continue
-                 */
-                if (!unsyncedReporter.length) {
-                    clearInterval(interval);
-                    return resolve(true);
-                }
-                log.info(`Wait for ${unsyncedReporter.length} reporter to synchronise`);
-                // wait otherwise
-            }, this._config.reporterSyncInterval);
-        });
-    }
-    /**
-     * initialize reporters
-     */
-    async _loadReporter(reporter) {
-        let ReporterClass;
-        let options = {};
-        /**
-         * check if reporter has custom options
-         */
-        if (Array.isArray(reporter)) {
-            options = Object.assign({}, options, reporter[1]);
-            reporter = reporter[0];
-        }
-        /**
-         * check if reporter was passed in from a file, e.g.
-         *
-         * ```js
-         * import MyCustomReporter from '/some/path/MyCustomReporter.js'
-         * export const config = {
-         *     //...
-         *     reporters: [
-         *         MyCustomReporter, // or
-         *         [MyCustomReporter, { custom: 'option' }]
-         *     ]
-         *     //...
-         * }
-         * ```
-         */
-        if (typeof reporter === 'function') {
-            ReporterClass = reporter;
-            options.logFile = options.setLogFile
-                ? options.setLogFile(this._cid, ReporterClass.name)
-                : typeof options.logFile === 'string'
-                    ? options.logFile
-                    : this.getLogFile(ReporterClass.name);
-            options.writeStream = this.getWriteStreamObject(ReporterClass.name);
-            return new ReporterClass(options);
-        }
-        /**
-         * check if reporter is a node package, e.g. wdio-dot reporter
-         *
-         * ```js
-         * export const config = {
-         *     //...
-         *     reporters: [
-         *         'dot', // or
-         *         ['dot', { custom: 'option' }]
-         *     ]
-         *     //...
-         * }
-         * ```
-         */
-        if (typeof reporter === 'string') {
-            ReporterClass = (await initializePlugin(reporter, 'reporter')).default;
-            options.logFile = options.setLogFile
-                ? options.setLogFile(this._cid, reporter)
-                : typeof options.logFile === 'string'
-                    ? options.logFile
-                    : this.getLogFile(reporter);
-            options.writeStream = this.getWriteStreamObject(reporter);
-            return new ReporterClass(options);
-        }
-        /**
-         * throw error if reporter property was invalid
-         */
-        throw new Error('Invalid reporters config');
-    }
-}

package/build/types.js

@@ -1 +0,0 @@
-export {};

package/build/utils.js

@@ -1,152 +0,0 @@
-import path from 'node:path';
-import { deepmerge } from 'deepmerge-ts';
-import logger from '@wdio/logger';
-import { remote, multiremote, attach } from 'webdriverio';
-import { DEFAULTS } from 'webdriver';
-import { DEFAULT_CONFIGS } from '@wdio/config';
-const log = logger('@wdio/runner');
-/**
- * sanitizes wdio config from capability properties
- * @param  {Object} caps  desired session capabilities
- * @return {Object}       sanitized caps
- */
-export function sanitizeCaps(caps, filterOut) {
-    const defaultConfigsKeys = [
-        // WDIO config keys
-        ...Object.keys(DEFAULT_CONFIGS()),
-        // WebDriver config keys
-        ...Object.keys(DEFAULTS)
-    ];
-    return Object.keys(caps).filter((key) => (
-    /**
-     * filter out all wdio config keys
-     */
-    !defaultConfigsKeys.includes(key) === !filterOut)).reduce((obj, key) => {
-        obj[key] = caps[key];
-        return obj;
-    }, {});
-}
-/**
- * initialize browser instance depending whether remote or multiremote is requested
- * @param  {Object}  config        configuration of sessions
- * @param  {Object}  capabilities  desired session capabilities
- * @param  {boolean} isMultiremote isMultiremote
- * @return {Promise}               resolves with browser object
- */
-export async function initializeInstance(config, capabilities, isMultiremote) {
-    /**
-     * Store all log events in a file
-     */
-    if (config.outputDir && !process.env.WDIO_LOG_PATH) {
-        process.env.WDIO_LOG_PATH = path.join(config.outputDir, 'wdio.log');
-    }
-    /**
-     * check if config has sessionId and attach it to a running session if so
-     */
-    if (config.sessionId) {
-        log.debug(`attach to session with id ${config.sessionId}`);
-        config.capabilities = sanitizeCaps(capabilities);
-        /**
-         * propagate connection details defined by services or user in capabilities
-         */
-        const caps = capabilities;
-        const connectionProps = {
-            protocol: caps.protocol || config.protocol,
-            hostname: caps.hostname || config.hostname,
-            port: caps.port || config.port,
-            path: caps.path || config.path
-        };
-        const params = { ...config, ...connectionProps, capabilities };
-        return attach({ ...params, options: params });
-    }
-    if (!isMultiremote) {
-        log.debug('init remote session');
-        const sessionConfig = {
-            ...config,
-            /**
-             * allow to overwrite connection details by user through capabilities
-             */
-            ...sanitizeCaps(capabilities, true),
-            capabilities: sanitizeCaps(capabilities)
-        };
-        return remote(sessionConfig);
-    }
-    const options = {};
-    log.debug('init multiremote session');
-    // @ts-expect-error ToDo(Christian): can be removed?
-    delete config.capabilities;
-    for (const browserName of Object.keys(capabilities)) {
-        options[browserName] = deepmerge(config, capabilities[browserName]);
-    }
-    const browser = await multiremote(options, config);
-    /**
-     * only attach to global environment if `injectGlobals` is set to true
-     */
-    const browserNames = config.injectGlobals ? Object.keys(capabilities) : [];
-    for (const browserName of browserNames) {
-        // @ts-ignore allow random global browser names
-        global[browserName] = browser[browserName];
-    }
-    return browser;
-}
-/**
- * Filter logTypes based on filter
- * @param  {string[]} excludeDriverLogs logTypes filter
- * @param  {string[]} driverLogTypes    available driver log types
- * @return {string[]}                   logTypes
- */
-export function filterLogTypes(excludeDriverLogs, driverLogTypes) {
-    let logTypes = [...driverLogTypes];
-    if (Array.isArray(excludeDriverLogs)) {
-        log.debug('filtering logTypes', logTypes);
-        logTypes = excludeDriverLogs.length === 1 && excludeDriverLogs[0] === '*'
-            ? []
-            : logTypes.filter(x => !excludeDriverLogs.includes(x)); // exclude specific logTypes
-        log.debug('filtered logTypes', logTypes);
-    }
-    return logTypes;
-}
-/**
- * Gets { sessionId, isW3C, protocol, hostname, port, path, queryParams } of every Multiremote instance
- * @param {object} browser browser
- * @param {boolean} isMultiremote isMultiremote
- * @return {object}
- */
-export function getInstancesData(browser, isMultiremote) {
-    if (!isMultiremote) {
-        return;
-    }
-    const multiRemoteBrowser = browser;
-    const instances = {};
-    multiRemoteBrowser.instances.forEach((browserName) => {
-        const { protocol, hostname, port, path, queryParams } = multiRemoteBrowser.getInstance(browserName).options;
-        const { isW3C, sessionId } = multiRemoteBrowser.getInstance(browserName);
-        instances[browserName] = { sessionId, isW3C, protocol, hostname, port, path, queryParams };
-    });
-    return instances;
-}
-const SUPPORTED_ASYMMETRIC_MATCHER = {
-    Any: 'any',
-    Anything: 'anything',
-    ArrayContaining: 'arrayContaining',
-    ObjectContaining: 'objectContaining',
-    StringContaining: 'stringContaining',
-    StringMatching: 'stringMatching',
-    CloseTo: 'closeTo'
-};
-/**
- * utility function to transform assertion parameters into asymmetric matchers if necessary
- * @param arg raw value or a stringified asymmetric matcher
- * @returns   raw value or an actual asymmetric matcher
- */
-export function transformExpectArgs(arg) {
-    if (typeof arg === 'object' && '$$typeof' in arg && Object.keys(SUPPORTED_ASYMMETRIC_MATCHER).includes(arg.$$typeof)) {
-        const matcherKey = SUPPORTED_ASYMMETRIC_MATCHER[arg.$$typeof];
-        const matcher = arg.inverse ? expect.not[matcherKey] : expect[matcherKey];
-        if (!matcher) {
-            throw new Error(`Matcher "${matcherKey}" is not supported by expect-webdriverio`);
-        }
-        return matcher(arg.sample);
-    }
-    return arg;
-}