webdriver 9.0.0-alpha.78 → 9.0.0

package/build/command.js

@@ -1,140 +0,0 @@
-import logger from '@wdio/logger';
-import { commandCallStructure, isValidParameter, getArgumentType } from '@wdio/utils';
-import { WebDriverBidiProtocol, } from '@wdio/protocols';
-import Request from './request/request.js';
-const log = logger('webdriver');
-const BIDI_COMMANDS = Object.values(WebDriverBidiProtocol).map((def) => def.socket.command);
-export default function (method, endpointUri, commandInfo, doubleEncodeVariables = false) {
-    const { command, deprecated, ref, parameters, variables = [], isHubCommand = false } = commandInfo;
-    return async function protocolCommand(...args) {
-        const isBidiCommand = BIDI_COMMANDS.includes(command);
-        let endpoint = endpointUri; // clone endpointUri in case we change it
-        const commandParams = [...variables.map((v) => Object.assign(v, {
-                /**
-                 * url variables are:
-                 */
-                required: true, // always required as they are part of the endpoint
-                type: 'string' // have to be always type of string
-            })), ...parameters];
-        const commandUsage = `${command}(${commandParams.map((p) => p.name).join(', ')})`;
-        const moreInfo = `\n\nFor more info see ${ref}\n`;
-        const body = {};
-        /**
-         * log deprecation warning if command is deprecated
-         */
-        if (typeof deprecated === 'string') {
-            log.warn(deprecated.replace('This command', `The "${command}" command`));
-        }
-        /**
-         * Throw this error message for all WebDriver Bidi commands.
-         * In case a successful connection to the browser bidi interface was established,
-         * we attach a custom Bidi prototype to the browser instance.
-         */
-        if (isBidiCommand) {
-            throw new Error(`Failed to execute WebDriver Bidi command "${command}" as no Bidi session ` +
-                'was established. Make sure you enable it by setting "webSocketUrl: true" ' +
-                'in your capabilities and verify that your environment and browser supports it.');
-        }
-        /**
-         * parameter check
-         */
-        const minAllowedParams = commandParams.filter((param) => param.required).length;
-        if (args.length < minAllowedParams || args.length > commandParams.length) {
-            const parameterDescription = commandParams.length
-                ? `\n\nProperty Description:\n${commandParams.map((p) => `  "${p.name}" (${p.type}): ${p.description}`).join('\n')}`
-                : '';
-            throw new Error(`Wrong parameters applied for ${command}\n` +
-                `Usage: ${commandUsage}` +
-                parameterDescription +
-                moreInfo);
-        }
-        /**
-         * parameter type check
-         */
-        for (const [it, arg] of Object.entries(args)) {
-            if (isBidiCommand) {
-                break;
-            }
-            const i = parseInt(it, 10);
-            const commandParam = commandParams[i];
-            if (!isValidParameter(arg, commandParam.type)) {
-                /**
-                 * ignore if argument is not required
-                 */
-                if (typeof arg === 'undefined' && !commandParam.required) {
-                    continue;
-                }
-                const actual = commandParam.type.endsWith('[]')
-                    ? `(${(Array.isArray(arg) ? arg : [arg]).map((a) => getArgumentType(a))})[]`
-                    : getArgumentType(arg);
-                throw new Error(`Malformed type for "${commandParam.name}" parameter of command ${command}\n` +
-                    `Expected: ${commandParam.type}\n` +
-                    `Actual: ${actual}` +
-                    moreInfo);
-            }
-            /**
-             * inject url variables
-             */
-            if (i < variables.length) {
-                const encodedArg = doubleEncodeVariables ? encodeURIComponent(encodeURIComponent(arg)) : encodeURIComponent(arg);
-                endpoint = endpoint.replace(`:${commandParams[i].name}`, encodedArg);
-                continue;
-            }
-            /**
-             * rest of args are part of body payload
-             */
-            body[commandParams[i].name] = arg;
-        }
-        const request = new Request(method, endpoint, body, isHubCommand);
-        request.on('performance', (...args) => this.emit('request.performance', ...args));
-        this.emit('command', { method, endpoint, body });
-        log.info('COMMAND', commandCallStructure(command, args));
-        /**
-         * use then here so we can better unit test what happens before and after the request
-         */
-        return request.makeRequest(this.options, this.sessionId).then((result) => {
-            if (typeof result.value !== 'undefined') {
-                let resultLog = result.value;
-                if (/screenshot|recording/i.test(command) && typeof result.value === 'string' && result.value.length > 64) {
-                    resultLog = `${result.value.slice(0, 61)}...`;
-                }
-                else if (command === 'executeScript' && body.script && body.script.includes('(() => window.__wdioEvents__)')) {
-                    resultLog = `[${result.value.length} framework events captured]`;
-                }
-                log.info('RESULT', resultLog);
-            }
-            this.emit('result', { method, endpoint, body, result });
-            if (command === 'deleteSession') {
-                const shutdownDriver = body.deleteSessionOpts?.shutdownDriver !== false;
-                /**
-                 * kill driver process if there is one
-                 */
-                if (shutdownDriver && 'wdio:driverPID' in this.capabilities && this.capabilities['wdio:driverPID']) {
-                    log.info(`Kill driver process with PID ${this.capabilities['wdio:driverPID']}`);
-                    const killedSuccessfully = process.kill(this.capabilities['wdio:driverPID'], 'SIGKILL');
-                    if (!killedSuccessfully) {
-                        log.warn('Failed to kill driver process, manually clean-up might be required');
-                    }
-                    setTimeout(() => {
-                        /**
-                         * clear up potential leaked TLS Socket handles
-                         * see https://github.com/puppeteer/puppeteer/pull/10667
-                         */
-                        for (const handle of process._getActiveHandles()) {
-                            if (handle.servername && handle.servername.includes('edgedl.me')) {
-                                handle.destroy();
-                            }
-                        }
-                    }, 10);
-                }
-                /**
-                 * clear logger stream if session has been terminated
-                 */
-                if (!process.env.WDIO_WORKER_ID) {
-                    logger.clearLogger();
-                }
-            }
-            return result.value;
-        });
-    };
-}

package/build/constants.js

@@ -1,146 +0,0 @@
-import os from 'node:os';
-export const DEFAULTS = {
-    /**
-     * protocol of automation driver
-     */
-    protocol: {
-        type: 'string',
-        default: 'http',
-        match: /(http|https)/
-    },
-    /**
-     * hostname of automation driver
-     */
-    hostname: {
-        type: 'string',
-        default: 'localhost'
-    },
-    /**
-     * port of automation driver
-     */
-    port: {
-        type: 'number'
-    },
-    /**
-     * path to WebDriver endpoints
-     */
-    path: {
-        type: 'string',
-        validate: (path) => {
-            if (!path.startsWith('/')) {
-                throw new TypeError('The option "path" needs to start with a "/"');
-            }
-            return true;
-        },
-        default: '/'
-    },
-    /**
-     * A key-value store of query parameters to be added to every selenium request
-     */
-    queryParams: {
-        type: 'object'
-    },
-    /**
-     * cloud user if applicable
-     */
-    user: {
-        type: 'string'
-    },
-    /**
-     * access key to user
-     */
-    key: {
-        type: 'string'
-    },
-    /**
-     * capability of WebDriver session
-     */
-    capabilities: {
-        type: 'object',
-        required: true
-    },
-    /**
-     * Level of logging verbosity
-     */
-    logLevel: {
-        type: 'string',
-        default: 'info',
-        match: /(trace|debug|info|warn|error|silent)/
-    },
-    /**
-     * directory for log files
-     */
-    outputDir: {
-        type: 'string'
-    },
-    /**
-     * Timeout for any WebDriver request to a driver or grid
-     */
-    connectionRetryTimeout: {
-        type: 'number',
-        default: 120000
-    },
-    /**
-     * Count of request retries to the Selenium server
-     */
-    connectionRetryCount: {
-        type: 'number',
-        default: 3
-    },
-    /**
-     * Override default agent
-     */
-    logLevels: {
-        type: 'object'
-    },
-    /**
-     * Pass custom headers
-     */
-    headers: {
-        type: 'object'
-    },
-    /**
-     * Function transforming the request options before the request is made
-     */
-    transformRequest: {
-        type: 'function',
-        default: (requestOptions) => requestOptions
-    },
-    /**
-     * Function transforming the response object after it is received
-     */
-    transformResponse: {
-        type: 'function',
-        default: (response) => response
-    },
-    /**
-     * Appium direct connect options server (https://appiumpro.com/editions/86-connecting-directly-to-appium-hosts-in-distributed-environments)
-     * Whether to allow direct connect caps to adjust endpoint details (Appium only)
-     */
-    enableDirectConnect: {
-        type: 'boolean',
-        default: true
-    },
-    /**
-     * Whether it requires SSL certificates to be valid in HTTP/s requests
-     * for an environment which cannot get process environment well.
-     */
-    strictSSL: {
-        type: 'boolean',
-        default: true
-    },
-    /**
-     * The path to the root of the cache directory. This directory is used to store all drivers that are downloaded
-     * when attempting to start a session.
-     */
-    cacheDir: {
-        type: 'string',
-        default: process.env.WEBDRIVER_CACHE_DIR || os.tmpdir()
-    }
-};
-export const REG_EXPS = {
-    commandName: /.*\/session\/[0-9a-f-]+\/(.*)/,
-    execFn: /return \(([\s\S]*)\)\.apply\(null, arguments\)/
-};
-export const ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
-export const SHADOW_ELEMENT_KEY = 'shadow-6066-11e4-a52e-4f735466cecf';

package/build/request/index.js

@@ -1,215 +0,0 @@
-import path from 'node:path';
-import { EventEmitter } from 'node:events';
-import { createRequire } from 'node:module';
-import { WebDriverProtocol } from '@wdio/protocols';
-import { URL } from 'node:url';
-import logger from '@wdio/logger';
-import { transformCommandLogResult } from '@wdio/utils';
-import { isSuccessfulResponse, getErrorFromResponseBody, getTimeoutError } from '../utils.js';
-let pkg = { version: '' };
-if ('process' in globalThis && globalThis.process.versions?.node) {
-    const require = createRequire(import.meta.url);
-    pkg = require('../../package.json');
-}
-const ERRORS_TO_EXCLUDE_FROM_RETRY = [
-    'detached shadow root',
-    'move target out of bounds'
-];
-export class RequestLibError extends Error {
-    statusCode;
-    body;
-    code;
-}
-export const COMMANDS_WITHOUT_RETRY = [
-    findCommandPathByName('performActions'),
-];
-const DEFAULT_HEADERS = {
-    'Content-Type': 'application/json; charset=utf-8',
-    'Connection': 'keep-alive',
-    'Accept': 'application/json',
-    'User-Agent': 'webdriver/' + pkg.version
-};
-const log = logger('webdriver');
-export default class WebDriverRequest extends EventEmitter {
-    body;
-    method;
-    endpoint;
-    isHubCommand;
-    requiresSessionId;
-    constructor(method, endpoint, body, isHubCommand = false) {
-        super();
-        this.body = body;
-        this.method = method;
-        this.endpoint = endpoint;
-        this.isHubCommand = isHubCommand;
-        this.requiresSessionId = Boolean(this.endpoint.match(/:sessionId/));
-    }
-    async makeRequest(options, sessionId) {
-        const { url, requestOptions } = await this._createOptions(options, sessionId);
-        let fullRequestOptions = Object.assign({ method: this.method }, requestOptions);
-        if (typeof options.transformRequest === 'function') {
-            fullRequestOptions = options.transformRequest(fullRequestOptions);
-        }
-        this.emit('request', fullRequestOptions);
-        return this._request(url, fullRequestOptions, options.transformResponse, options.connectionRetryCount, 0);
-    }
-    async _createOptions(options, sessionId, isBrowser = false) {
-        const controller = new AbortController();
-        setTimeout(() => controller.abort(), options.connectionRetryTimeout || 120000);
-        const requestOptions = {
-            signal: controller.signal
-        };
-        const requestHeaders = new Headers({
-            ...DEFAULT_HEADERS,
-            ...(typeof options.headers === 'object' ? options.headers : {})
-        });
-        const searchParams = isBrowser ? undefined : (typeof options.queryParams === 'object' ? options.queryParams : undefined);
-        /**
-         * only apply body property if existing
-         */
-        if (this.body && (Object.keys(this.body).length || this.method === 'POST')) {
-            const contentLength = Buffer.byteLength(JSON.stringify(this.body), 'utf8');
-            requestOptions.body = this.body;
-            requestHeaders.set('Content-Length', `${contentLength}`);
-        }
-        /**
-         * if we don't have a session id we set it here, unless we call commands that don't require session ids, for
-         * example /sessions. The call to /sessions is not connected to a session itself and it therefore doesn't
-         * require it
-         */
-        let endpoint = this.endpoint;
-        if (this.requiresSessionId) {
-            if (!sessionId) {
-                throw new Error('A sessionId is required for this command');
-            }
-            endpoint = endpoint.replace(':sessionId', sessionId);
-        }
-        const url = new URL(`${options.protocol}://${options.hostname}:${options.port}${this.isHubCommand ? this.endpoint : path.join(options.path || '', endpoint)}`);
-        if (searchParams) {
-            url.search = new URLSearchParams(searchParams).toString();
-        }
-        /**
-         * send authentication credentials only when creating new session
-         */
-        if (this.endpoint === '/session' && options.user && options.key) {
-            requestHeaders.set('Authorization', 'Basic ' + btoa(options.user + ':' + options.key));
-        }
-        requestOptions.headers = requestHeaders;
-        return { url, requestOptions };
-    }
-    async _libRequest(url, options) {
-        throw new Error('This function must be implemented');
-    }
-    _libPerformanceNow() {
-        throw new Error('This function must be implemented');
-    }
-    async _request(url, fullRequestOptions, transformResponse, totalRetryCount = 0, retryCount = 0) {
-        log.info(`[${fullRequestOptions.method}] ${url.href}`);
-        if (fullRequestOptions.body && Object.keys(fullRequestOptions.body).length) {
-            log.info('DATA', transformCommandLogResult(fullRequestOptions.body));
-        }
-        const { ...requestLibOptions } = fullRequestOptions;
-        const startTime = this._libPerformanceNow();
-        let response = await this._libRequest(url, requestLibOptions)
-            .catch((err) => err);
-        const durationMillisecond = this._libPerformanceNow() - startTime;
-        /**
-         * handle retries for requests
-         * @param {Error} error  error object that causes the retry
-         * @param {string} msg   message that is being shown as warning to user
-         */
-        const retry = (error, msg) => {
-            /**
-             * stop retrying if totalRetryCount was exceeded or there is no reason to
-             * retry, e.g. if sessionId is invalid
-             */
-            if (retryCount >= totalRetryCount || error.message.includes('invalid session id')) {
-                log.error(`Request failed with status ${response.statusCode} due to ${error}`);
-                this.emit('response', { error });
-                this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: false, error, retryCount });
-                throw error;
-            }
-            ++retryCount;
-            this.emit('retry', { error, retryCount });
-            this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: false, error, retryCount });
-            log.warn(msg);
-            log.info(`Retrying ${retryCount}/${totalRetryCount}`);
-            return this._request(url, fullRequestOptions, transformResponse, totalRetryCount, retryCount);
-        };
-        /**
-         * handle request errors
-         */
-        if (response instanceof Error) {
-            /**
-             * handle timeouts
-             */
-            if (response.code === 'ETIMEDOUT') {
-                const error = getTimeoutError(response, fullRequestOptions, url);
-                return retry(error, 'Request timed out! Consider increasing the "connectionRetryTimeout" option.');
-            }
-            /**
-             * throw if request error is unknown
-             */
-            this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: false, error: response, retryCount });
-            throw response;
-        }
-        if (typeof transformResponse === 'function') {
-            response = transformResponse(response, fullRequestOptions);
-        }
-        const error = getErrorFromResponseBody(response.body, fullRequestOptions.body);
-        /**
-         * retry connection refused errors
-         */
-        if (error.message === 'java.net.ConnectException: Connection refused: connect') {
-            return retry(error, 'Connection to Selenium Standalone server was refused.');
-        }
-        /**
-         * hub commands don't follow standard response formats
-         * and can have empty bodies
-         */
-        if (this.isHubCommand) {
-            /**
-             * if body contains HTML the command was called on a node
-             * directly without using a hub, therefore throw
-             */
-            if (typeof response.body === 'string' && response.body.startsWith('<!DOCTYPE html>')) {
-                this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: false, error, retryCount });
-                return Promise.reject(new Error('Command can only be called to a Selenium Hub'));
-            }
-            return { value: response.body || null };
-        }
-        /**
-         * Resolve only if successful response
-         */
-        if (isSuccessfulResponse(response.statusCode, response.body)) {
-            this.emit('response', { result: response.body });
-            this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: true, retryCount });
-            return response.body;
-        }
-        /**
-         * stop retrying as this will never be successful.
-         * we will handle this at the elementErrorHandler
-         */
-        if (error.name === 'stale element reference') {
-            log.warn('Request encountered a stale element - terminating request');
-            this.emit('response', { error });
-            this.emit('performance', { request: fullRequestOptions, durationMillisecond, success: false, error, retryCount });
-            throw error;
-        }
-        /**
-         * some errors can be excluded from the request retry mechanism as
-         * it likely does not changes anything and the error is handled within the command.
-         */
-        if (ERRORS_TO_EXCLUDE_FROM_RETRY.includes(error.name)) {
-            throw error;
-        }
-        return retry(error, `Request failed with status ${response.statusCode} due to ${error.message}`);
-    }
-}
-function findCommandPathByName(commandName) {
-    const command = Object.entries(WebDriverProtocol).find(([, command]) => Object.values(command).find((cmd) => cmd.command === commandName));
-    if (!command) {
-        throw new Error(`Couldn't find command "${commandName}"`);
-    }
-    return command[0];
-}

package/build/request/request.js

@@ -1,38 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import dns from 'node:dns';
-import WebDriverRequest, { RequestLibError } from './index.js';
-// As per this https://github.com/node-fetch/node-fetch/issues/1624#issuecomment-1407717012 we are setting ipv4first as default IP resolver.
-// This can be removed when we drop Node18 support.
-if ('process' in globalThis && globalThis.process.versions?.node) {
-    dns.setDefaultResultOrder('ipv4first');
-}
-export default class FetchRequest extends WebDriverRequest {
-    constructor(method, endpoint, body, isHubCommand = false) {
-        super(method, endpoint, body, isHubCommand);
-    }
-    async _libRequest(url, opts) {
-        try {
-            const response = await fetch(url, {
-                method: opts.method,
-                body: JSON.stringify(opts.body),
-                headers: opts.headers,
-                signal: opts.signal,
-            });
-            // Cloning the response to prevent body unusable error
-            const resp = response.clone();
-            return {
-                statusCode: resp.status,
-                body: await resp.json() ?? {},
-            };
-        }
-        catch (err) {
-            if (!(err instanceof Error)) {
-                throw new RequestLibError(err.message || err);
-            }
-            throw err;
-        }
-    }
-    _libPerformanceNow() {
-        return performance.now();
-    }
-}

package/build/types.js

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