@wdio/utils 9.0.0-alpha.9 → 9.0.4

package/build/monad.js

@@ -1,196 +0,0 @@
-import { EventEmitter } from 'node:events';
-import logger from '@wdio/logger';
-import { MESSAGE_TYPES } from '@wdio/types';
-import { commandCallStructure, overwriteElementCommands } from './utils.js';
-const SCOPE_TYPES = {
-    browser: /* istanbul ignore next */ function Browser() { },
-    element: /* istanbul ignore next */ function Element() { }
-};
-export default function WebDriver(options, modifier, propertiesObject = {}) {
-    /**
-     * In order to allow named scopes for elements we have to propagate that
-     * info within the `propertiesObject` object. This doesn't have any functional
-     * advantages just provides better description of objects when debugging them
-     */
-    const scopeType = SCOPE_TYPES[propertiesObject.scope?.value || 'browser'];
-    delete propertiesObject.scope;
-    const prototype = Object.create(scopeType.prototype);
-    const log = logger('webdriver');
-    const eventHandler = new EventEmitter();
-    const EVENTHANDLER_FUNCTIONS = Object.getPrototypeOf(eventHandler);
-    /**
-     * WebDriver monad
-     */
-    function unit(sessionId, commandWrapper) {
-        /**
-         * capabilities attached to the instance prototype not being shown if
-         * logging the instance
-         */
-        propertiesObject.commandList = { value: Object.keys(propertiesObject) };
-        propertiesObject.options = { value: options };
-        propertiesObject.requestedCapabilities = { value: options.requestedCapabilities };
-        /**
-         * allow to wrap commands if necessary
-         * e.g. in wdio-cli to allow element chaining
-         */
-        if (typeof commandWrapper === 'function') {
-            for (const [commandName, { value }] of Object.entries(propertiesObject)) {
-                if (typeof value !== 'function') {
-                    continue;
-                }
-                propertiesObject[commandName].value = commandWrapper(commandName, value, propertiesObject);
-                propertiesObject[commandName].configurable = true;
-            }
-        }
-        /**
-         * overwrite native element commands with user defined
-         */
-        overwriteElementCommands.call(this, propertiesObject);
-        /**
-         * assign propertiesObject to itself so the client can be recreated
-         */
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { puppeteer, ...propertiesObjectWithoutPuppeteer } = propertiesObject;
-        propertiesObject.__propertiesObject__ = { value: propertiesObjectWithoutPuppeteer };
-        let client = Object.create(prototype, propertiesObject);
-        client.sessionId = sessionId;
-        /**
-         * register capabilities only to browser scope
-         */
-        if (scopeType.name === 'Browser') {
-            client.capabilities = options.capabilities;
-        }
-        if (typeof modifier === 'function') {
-            client = modifier(client, options);
-        }
-        client.addCommand = function (name, func, attachToElement = false, proto, instances) {
-            const customCommand = typeof commandWrapper === 'function'
-                ? commandWrapper(name, func)
-                : func;
-            if (attachToElement) {
-                /**
-                 * add command to every multiremote instance
-                 */
-                if (instances) {
-                    Object.values(instances).forEach(instance => {
-                        instance.__propertiesObject__[name] = {
-                            value: customCommand
-                        };
-                    });
-                }
-                this.__propertiesObject__[name] = { value: customCommand };
-            }
-            else {
-                unit.lift(name, customCommand, proto);
-            }
-            /**
-             * When running component tests, custom commands might not be recognised when services attach them to the browser.
-             * This is because the `addCommand` function is called within the Node.js environment and not the browser.
-             * As a workaround, we check here if we are in a worker process and if so we send a message to the parent process
-             * to add the command to the browser.
-             *
-             * @todo(Christian): this won't be sufficient, e.g. in cases where the page is reloaded and the command is not re-added.
-             */
-            if (typeof process.send === 'function' && process.env.WDIO_WORKER_ID) {
-                const message = {
-                    origin: 'worker',
-                    name: 'workerEvent',
-                    args: {
-                        type: MESSAGE_TYPES.customCommand,
-                        value: {
-                            commandName: name,
-                            cid: process.env.WDIO_WORKER_ID,
-                        }
-                    }
-                };
-                process.send(message);
-            }
-        };
-        /**
-         * overwriteCommand
-         * @param  {string}   name              command name to be overwritten
-         * @param  {Function} func              function to replace original command with;
-         *                                      takes original function as first argument.
-         * @param  {boolean=} attachToElement   overwrite browser command (false) or element command (true)
-         * @param  {Object=}  proto             prototype to add function to (optional)
-         * @param  {Object=}  instances         multiremote instances
-         */
-        client.overwriteCommand = function (name, func, attachToElement = false, proto, instances) {
-            const customCommand = typeof commandWrapper === 'function'
-                ? commandWrapper(name, func)
-                : func;
-            if (attachToElement) {
-                if (instances) {
-                    /**
-                     * add command to every multiremote instance
-                     */
-                    Object.values(instances).forEach(instance => {
-                        instance.__propertiesObject__.__elementOverrides__.value[name] = customCommand;
-                    });
-                }
-                else {
-                    /**
-                     * regular mode
-                     */
-                    this.__propertiesObject__.__elementOverrides__.value[name] = customCommand;
-                }
-            }
-            else if (client[name]) {
-                const origCommand = client[name];
-                delete client[name];
-                unit.lift(name, customCommand, proto, (...args) => origCommand.apply(this, args));
-            }
-            else {
-                throw new Error('overwriteCommand: no command to be overwritten: ' + name);
-            }
-        };
-        return client;
-    }
-    /**
-     * Enhance monad prototype with function
-     * @param  {string}   name          name of function to attach to prototype
-     * @param  {Function} func          function to be added to prototype
-     * @param  {Object}   proto         prototype to add function to (optional)
-     * @param  {Function} origCommand   original command to be passed to custom command as first argument
-     */
-    unit.lift = function (name, func, proto, origCommand) {
-        (proto || prototype)[name] = function next(...args) {
-            log.info('COMMAND', commandCallStructure(name, args));
-            /**
-             * set name of function for better error stack
-             */
-            Object.defineProperty(func, 'name', {
-                value: name,
-                writable: false,
-            });
-            const result = func.apply(this, origCommand ? [origCommand, ...args] : args);
-            /**
-             * always transform result into promise
-             */
-            Promise.resolve(result).then((res) => {
-                const elem = res;
-                let resultLog = res;
-                if (elem instanceof SCOPE_TYPES.element) {
-                    resultLog = `WebdriverIO.Element<${elem.elementId || elem.selector}>`;
-                }
-                else if (res instanceof SCOPE_TYPES.browser) {
-                    resultLog = 'WebdriverIO.Browser';
-                }
-                log.info('RESULT', resultLog);
-                this.emit('result', { name, result: res });
-            }).catch(() => { });
-            return result;
-        };
-    };
-    /**
-     * register event emitter
-     */
-    for (const eventCommand in EVENTHANDLER_FUNCTIONS) {
-        prototype[eventCommand] = function (...args) {
-            const method = eventCommand;
-            eventHandler[method]?.(...args);
-            return this;
-        };
-    }
-    return unit;
-}

package/build/node/index.js

@@ -1,3 +0,0 @@
-export { startWebDriver } from './startWebDriver.js';
-export { setupDriver, setupBrowser } from './manager.js';
-export { canAccess } from './utils.js';

package/build/node/manager.js

@@ -1,106 +0,0 @@
-import logger from '@wdio/logger';
-import { getCacheDir, getDriverOptions, setupChromedriver, setupEdgedriver, setupGeckodriver, setupPuppeteerBrowser } from './utils.js';
-import { definesRemoteDriver, isSafari, isEdge, isFirefox, isChrome } from '../utils.js';
-const log = logger('@wdio/utils');
-const UNDEFINED_BROWSER_VERSION = null;
-var BrowserDriverTaskLabel;
-(function (BrowserDriverTaskLabel) {
-    BrowserDriverTaskLabel["BROWSER"] = "browser binaries";
-    BrowserDriverTaskLabel["DRIVER"] = "browser driver";
-})(BrowserDriverTaskLabel || (BrowserDriverTaskLabel = {}));
-function mapCapabilities(options, caps, task, taskItemLabel) {
-    const capabilitiesToRequireSetup = (Array.isArray(caps)
-        ? caps.map((cap) => {
-            const w3cCaps = cap;
-            const multiremoteCaps = cap;
-            const isMultiremote = Boolean(multiremoteCaps[Object.keys(cap)[0]].capabilities);
-            if (isMultiremote) {
-                return Object.values(multiremoteCaps).map((c) => c.capabilities);
-            }
-            else if (w3cCaps.alwaysMatch) {
-                return w3cCaps.alwaysMatch;
-            }
-            return cap;
-        }).flat()
-        : Object.values(caps).map((mrOpts) => {
-            const w3cCaps = mrOpts.capabilities;
-            if (w3cCaps.alwaysMatch) {
-                return w3cCaps.alwaysMatch;
-            }
-            return mrOpts.capabilities;
-        })).flat().filter((cap) => (
-    /**
-     * only set up driver if
-     */
-    // - capabilities are defined and not empty
-    cap &&
-        // - browserName is defined so we know it is a browser session
-        cap.browserName &&
-        // - we are not about to run a cloud session
-        !definesRemoteDriver(options) &&
-        // - we are not running Safari (driver already installed on macOS)
-        !isSafari(cap.browserName) &&
-        // - driver options don't define a binary path
-        !getDriverOptions(cap).binary));
-    /**
-     * nothing to setup
-     */
-    if (capabilitiesToRequireSetup.length === 0) {
-        return;
-    }
-    /**
-     * get all browser names and versions that need driver setup
-     */
-    const queueByBrowserName = capabilitiesToRequireSetup.reduce((queue, cap) => {
-        if (!cap.browserName) {
-            return queue;
-        }
-        if (!queue.has(cap.browserName)) {
-            queue.set(cap.browserName, new Map());
-        }
-        const browserVersion = cap.browserVersion || UNDEFINED_BROWSER_VERSION;
-        queue.get(cap.browserName).set(browserVersion, cap);
-        return queue;
-    }, new Map());
-    const driverToSetupString = Array.from(queueByBrowserName.entries())
-        .map(([browserName, versions]) => `${browserName}@${Array.from(versions.keys()).map((bv) => bv || 'stable').join(', ')}`)
-        .join(' - ');
-    log.info(`Setting up ${taskItemLabel} for: ${driverToSetupString}`);
-    return Promise.all(Array.from(queueByBrowserName.entries()).map(([browserName, queueByBrowserVersion]) => {
-        return Array.from(queueByBrowserVersion).map(([browserVersion, cap]) => task({
-            ...cap,
-            browserName,
-            ...(browserVersion !== UNDEFINED_BROWSER_VERSION ? { browserVersion } : {})
-        }));
-    }).flat());
-}
-export async function setupDriver(options, caps) {
-    return mapCapabilities(options, caps, async (cap) => {
-        const cacheDir = getCacheDir(options, cap);
-        if (isEdge(cap.browserName)) {
-            return setupEdgedriver(cacheDir, cap.browserVersion);
-        }
-        else if (isFirefox(cap.browserName)) {
-            // "latest" works for setting up browser only but not geckodriver
-            const version = cap.browserVersion === 'latest' ? undefined : cap.browserVersion;
-            return setupGeckodriver(cacheDir, version);
-        }
-        else if (isChrome(cap.browserName)) {
-            return setupChromedriver(cacheDir, cap.browserVersion);
-        }
-        return Promise.resolve();
-    }, BrowserDriverTaskLabel.DRIVER);
-}
-export function setupBrowser(options, caps) {
-    return mapCapabilities(options, caps, async (cap) => {
-        const cacheDir = getCacheDir(options, cap);
-        if (isEdge(cap.browserName)) {
-            // not yet implemented
-            return Promise.resolve();
-        }
-        else if (isChrome(cap.browserName) || isFirefox(cap.browserName)) {
-            return setupPuppeteerBrowser(cacheDir, cap);
-        }
-        return Promise.resolve();
-    }, BrowserDriverTaskLabel.BROWSER);
-}

package/build/node/startWebDriver.js

@@ -1,140 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import cp from 'node:child_process';
-import getPort from 'get-port';
-import waitPort from 'wait-port';
-import logger from '@wdio/logger';
-import split2 from 'split2';
-import { deepmerge } from 'deepmerge-ts';
-import { start as startSafaridriver } from 'safaridriver';
-import { start as startGeckodriver } from 'geckodriver';
-import { start as startEdgedriver, findEdgePath } from 'edgedriver';
-import { parseParams, setupPuppeteerBrowser, setupChromedriver, getCacheDir } from './utils.js';
-import { isChrome, isFirefox, isEdge, isSafari, isAppiumCapability } from '../utils.js';
-import { SUPPORTED_BROWSERNAMES } from '../constants.js';
-const log = logger('@wdio/utils');
-const DRIVER_WAIT_TIMEOUT = 10 * 1000; // 10s
-export async function startWebDriver(options) {
-    /**
-     * in case we are running unit tests, just return
-     */
-    if (process.env.WDIO_SKIP_DRIVER_SETUP) {
-        options.hostname = 'localhost';
-        options.port = 4321;
-        return;
-    }
-    let driverProcess;
-    let driver = '';
-    const start = Date.now();
-    const caps = options.capabilities.alwaysMatch || options.capabilities;
-    /**
-     * session might be a mobile session so don't do anything
-     */
-    if (isAppiumCapability(caps)) {
-        return;
-    }
-    if (!caps.browserName) {
-        throw new Error('No "browserName" defined in capabilities nor hostname or port found!\n' +
-            'If you like to run a local browser session make sure to pick from one of ' +
-            `the following browser names: ${Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity)}`);
-    }
-    const port = await getPort();
-    const cacheDir = getCacheDir(options, caps);
-    if (isChrome(caps.browserName)) {
-        /**
-         * Chrome
-         */
-        const chromedriverOptions = caps['wdio:chromedriverOptions'] || {};
-        const { executablePath: chromeExecuteablePath, browserVersion } = await setupPuppeteerBrowser(cacheDir, caps);
-        const { executablePath: chromedriverExcecuteablePath } = chromedriverOptions.binary
-            ? { executablePath: chromedriverOptions.binary }
-            : await setupChromedriver(cacheDir, browserVersion);
-        caps['goog:chromeOptions'] = deepmerge({ binary: chromeExecuteablePath }, caps['goog:chromeOptions'] || {});
-        chromedriverOptions.allowedOrigins = chromedriverOptions.allowedOrigins || ['*'];
-        chromedriverOptions.allowedIps = chromedriverOptions.allowedIps || ['0.0.0.0'];
-        const driverParams = parseParams({ port, ...chromedriverOptions });
-        driverProcess = cp.spawn(chromedriverExcecuteablePath, driverParams);
-        driver = `Chromedriver v${browserVersion} with params ${driverParams.join(' ')}`;
-    }
-    else if (isSafari(caps.browserName)) {
-        const safaridriverOptions = caps['wdio:safaridriverOptions'] || {};
-        /**
-         * Safari
-         */
-        driver = 'SafariDriver';
-        driverProcess = startSafaridriver({
-            useTechnologyPreview: Boolean(caps.browserName.match(/preview/i)),
-            ...safaridriverOptions,
-            port
-        });
-    }
-    else if (isFirefox(caps.browserName)) {
-        /**
-         * Firefox
-         */
-        const { executablePath } = await setupPuppeteerBrowser(cacheDir, caps);
-        caps['moz:firefoxOptions'] = deepmerge({ binary: executablePath }, caps['moz:firefoxOptions'] || {});
-        /**
-         * the "binary" parameter refers to the driver binary in the WebdriverIO.GeckodriverOptions and
-         * to the Firefox binary in the driver option
-         */
-        delete caps.browserVersion;
-        const { binary, ...geckodriverOptions } = caps['wdio:geckodriverOptions'] || {};
-        if (binary) {
-            geckodriverOptions.customGeckoDriverPath = binary;
-        }
-        driver = 'GeckoDriver';
-        driverProcess = await startGeckodriver({ ...geckodriverOptions, cacheDir, port, allowHosts: ['localhost'] });
-    }
-    else if (isEdge(caps.browserName)) {
-        /**
-         * Microsoft Edge
-         */
-        const { binary, ...edgedriverOptions } = caps['wdio:edgedriverOptions'] || {};
-        if (binary) {
-            edgedriverOptions.customEdgeDriverPath = binary;
-        }
-        driver = 'EdgeDriver';
-        driverProcess = await startEdgedriver({ ...edgedriverOptions, cacheDir, port, allowedIps: ['0.0.0.0'] }).catch((err) => {
-            log.warn(`Couldn't start EdgeDriver: ${err.message}, retry ...`);
-            return startEdgedriver({ ...edgedriverOptions, cacheDir, port });
-        });
-        /**
-         * Microsoft Edge is very particular when it comes to browser names
-         */
-        caps.browserName = 'MicrosoftEdge';
-        /**
-         * on Linux set the path to the Edge binary if not already set
-         */
-        if (!caps['ms:edgeOptions']?.binary && os.platform() !== 'darwin' && os.platform() !== 'win32') {
-            caps['ms:edgeOptions'] = caps['ms:edgeOptions'] || {};
-            caps['ms:edgeOptions'].binary = findEdgePath();
-        }
-    }
-    else {
-        throw new Error(`Unknown browser name "${caps.browserName}". Make sure to pick from one of the following ` +
-            Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity));
-    }
-    const logIdentifier = driver.split(' ').shift()?.toLowerCase() || 'driver';
-    if (options.outputDir) {
-        const logFileName = process.env.WDIO_WORKER_ID
-            ? `wdio-${process.env.WDIO_WORKER_ID}-${logIdentifier}.log`
-            : `wdio-${logIdentifier}-${port}.log`;
-        const logFile = path.resolve(options.outputDir, logFileName);
-        const logStream = fs.createWriteStream(logFile, { flags: 'w' });
-        driverProcess.stdout?.pipe(logStream);
-        driverProcess.stderr?.pipe(logStream);
-    }
-    else {
-        const driverLog = logger(logIdentifier);
-        driverProcess.stdout?.pipe(split2()).on('data', driverLog.info.bind(driverLog));
-        driverProcess.stderr?.pipe(split2()).on('data', driverLog.warn.bind(driverLog));
-    }
-    await waitPort({ port, output: 'silent', timeout: DRIVER_WAIT_TIMEOUT })
-        .catch((e) => { throw new Error(`Timed out to connect to ${driver}: ${e.message}`); });
-    options.hostname = 'localhost';
-    options.port = port;
-    log.info(`Started ${driver} in ${Date.now() - start}ms on port ${port}`);
-    return driverProcess;
-}