@wdio/utils 9.0.0-alpha.9 → 9.0.4

package/build/shim.js

@@ -1,293 +0,0 @@
-import logger from '@wdio/logger';
-import * as iterators from './pIteration.js';
-const log = logger('@wdio/utils:shim');
-let inCommandHook = false;
-const ELEMENT_QUERY_COMMANDS = [
-    '$', '$$', 'custom$', 'custom$$', 'shadow$', 'shadow$$', 'react$',
-    'react$$', 'nextElement', 'previousElement', 'parentElement'
-];
-const ELEMENT_PROPS = [
-    'elementId', 'error', 'selector', 'parent', 'index', 'isReactElement',
-    'length'
-];
-const ACTION_COMMANDS = ['action', 'actions'];
-const PROMISE_METHODS = ['then', 'catch', 'finally'];
-const TIME_BUFFER = 3;
-export async function executeHooksWithArgs(hookName, hooks = [], args = []) {
-    /**
-     * make sure hooks are an array of functions
-     */
-    if (!Array.isArray(hooks)) {
-        hooks = [hooks];
-    }
-    /**
-     * make sure args is an array since we are calling apply
-     */
-    if (!Array.isArray(args)) {
-        args = [args];
-    }
-    const hooksPromises = hooks.map((hook) => new Promise((resolve, reject) => {
-        let result;
-        try {
-            result = hook.apply(this, args);
-        }
-        catch (e) {
-            /**
-             * When we use `this.skip()` inside a test or a hook, it's a signal that we want to stop that particular test.
-             * Mocha, the testing framework, knows how to handle this for its own built-in hooks and test steps.
-             * However, for our custom hooks, we need to reject the promise, which effectively skips the test case.
-             * For more details, refer to: https://github.com/mochajs/mocha/pull/3859#issuecomment-534116333
-             */
-            if (/^(sync|async) skip; aborting execution$/.test(e.message)) {
-                return reject();
-            }
-            /**
-            * in case of jasmine, when rejecting, we need to pass the message of rejection as well
-            */
-            if (/^=> marked Pending/.test(e)) {
-                return reject(e);
-            }
-            log.error(e.stack);
-            return resolve(e);
-        }
-        /**
-         * if a promise is returned make sure we don't have a catch handler
-         * so in case of a rejection it won't cause the hook to fail
-         */
-        if (result && typeof result.then === 'function') {
-            return result.then(resolve, (e) => {
-                log.error(e.stack || e.message);
-                resolve(e);
-            });
-        }
-        resolve(result);
-    }));
-    const start = Date.now();
-    const result = await Promise.all(hooksPromises);
-    if (hooksPromises.length) {
-        log.debug(`Finished to run "${hookName}" hook in ${Date.now() - start}ms`);
-    }
-    return result;
-}
-/**
- * wrap command to enable before and after command to be executed
- * @param commandName name of the command (e.g. getTitle)
- * @param fn          command function
- */
-export function wrapCommand(commandName, fn) {
-    async function wrapCommandFn(...args) {
-        const beforeHookArgs = [commandName, args];
-        if (!inCommandHook && this.options.beforeCommand) {
-            inCommandHook = true;
-            await executeHooksWithArgs.call(this, 'beforeCommand', this.options.beforeCommand, beforeHookArgs);
-            inCommandHook = false;
-        }
-        let commandResult;
-        let commandError;
-        try {
-            commandResult = await fn.apply(this, args);
-        }
-        catch (err) {
-            commandError = err;
-        }
-        if (!inCommandHook && this.options.afterCommand) {
-            inCommandHook = true;
-            const afterHookArgs = [...beforeHookArgs, commandResult, commandError];
-            await executeHooksWithArgs.call(this, 'afterCommand', this.options.afterCommand, afterHookArgs);
-            inCommandHook = false;
-        }
-        if (commandError) {
-            throw commandError;
-        }
-        return commandResult;
-    }
-    function wrapElementFn(promise, cmd, args, prevInnerArgs) {
-        return new Proxy(Promise.resolve(promise).then((ctx) => cmd.call(ctx, ...args)), {
-            get: (target, prop) => {
-                /**
-                 * handle symbols, e.g. async iterators
-                 */
-                if (typeof prop === 'symbol') {
-                    return () => ({
-                        i: 0,
-                        target,
-                        async next() {
-                            const elems = await this.target;
-                            if (!Array.isArray(elems)) {
-                                throw new Error('Can not iterate over non array');
-                            }
-                            if (this.i < elems.length) {
-                                return { value: elems[this.i++], done: false };
-                            }
-                            return { done: true };
-                        }
-                    });
-                }
-                /**
-                 * if we access an index on an element array promise, e.g.:
-                 * ```js
-                 * const elems = await $$('foo')[2]
-                 * ```
-                 */
-                const numValue = parseInt(prop, 10);
-                if (!isNaN(numValue)) {
-                    return wrapElementFn(target, 
-                    /**
-                     * `this` is an array of WebdriverIO elements
-                     *
-                     * Note(Christian): types for elements are defined in the
-                     * webdriverio package and not accessible here
-                     */
-                    function (index) {
-                        return this[index];
-                    }, [prop], { prop, args });
-                }
-                /**
-                 * if we call a query method on a resolve promise, e.g.:
-                 * ```js
-                 * await $('foo').$('bar')
-                 * ```
-                 */
-                if (ELEMENT_QUERY_COMMANDS.includes(prop) || prop.endsWith('$')) {
-                    // this: WebdriverIO.Element
-                    return wrapCommand(prop, function (...args) {
-                        return this[prop].apply(this, args);
-                    });
-                }
-                /**
-                 * if we call an array iterator function like map or forEach on an
-                 * set of elements, e.g.:
-                 * ```js
-                 * await $('body').$('header').$$('div').map((elem) => elem.getLocation())
-                 * ```
-                 */
-                if (commandName.endsWith('$$') && typeof iterators[prop] === 'function') {
-                    return (mapIterator) => wrapElementFn(target, function (mapIterator) {
-                        // @ts-ignore
-                        return iterators[prop](this, mapIterator);
-                    }, [mapIterator]);
-                }
-                /**
-                 * allow to grab the length or other properties of fetched element set, e.g.:
-                 * ```js
-                 * const elemAmount = await $$('foo').length
-                 * ```
-                 */
-                if (ELEMENT_PROPS.includes(prop)) {
-                    return target.then((res) => res[prop]);
-                }
-                /**
-                 * allow to resolve an chained element query, e.g.:
-                 * ```js
-                 * const elem = await $('foo').$('bar')
-                 * console.log(elem.selector) // "bar"
-                 * ```
-                 */
-                if (PROMISE_METHODS.includes(prop)) {
-                    return target[prop].bind(target);
-                }
-                /**
-                 * call a command on an element query, e.g.:
-                 * ```js
-                 * const tagName = await $('foo').$('bar').getTagName()
-                 * ```
-                 */
-                return (...args) => target.then(async (elem) => {
-                    if (!elem) {
-                        let errMsg = 'Element could not be found';
-                        const prevElem = await promise;
-                        if (Array.isArray(prevElem) && prevInnerArgs && prevInnerArgs.prop === 'get') {
-                            errMsg = `Index out of bounds! $$(${prevInnerArgs.args[0]}) returned only ${prevElem.length} elements.`;
-                        }
-                        throw new Error(errMsg);
-                    }
-                    /**
-                     * Jasmine uses `toJSON` to parse the target object for information.
-                     * Since WebdriverIo doesn't have this method on the Element object
-                     * we need to mimic it here
-                     */
-                    if (prop === 'toJSON') {
-                        return { ELEMENT: elem.elementId };
-                    }
-                    /**
-                     * provide a better error message than "TypeError: elem[prop] is not a function"
-                     */
-                    if (typeof elem[prop] !== 'function') {
-                        throw new Error(`Can't call "${prop}" on element with selector "${elem.selector}", it is not a function`);
-                    }
-                    return elem[prop](...args);
-                });
-            }
-        });
-    }
-    function chainElementQuery(...args) {
-        return wrapElementFn(this, wrapCommandFn, args);
-    }
-    return function (...args) {
-        /**
-         * if the command suppose to return an element, we apply `chainElementQuery` to allow
-         * chaining of these promises.
-         */
-        const command = ELEMENT_QUERY_COMMANDS.includes(commandName) || commandName.endsWith('$')
-            ? chainElementQuery
-            : ACTION_COMMANDS.includes(commandName)
-                /**
-                 * actions commands are a bit special as they return their own
-                 * sync interface
-                 */
-                ? fn
-                : wrapCommandFn;
-        return command.apply(this, args);
-    };
-}
-/**
- * execute test or hook asynchronously
- *
- * @param  {Function} fn         spec or hook method
- * @param  {object}   retries    { limit: number, attempts: number }
- * @param  {Array}    args       arguments passed to hook
- * @param  {number}   timeout    The maximum time (in milliseconds) to wait for the function to complete
- * @return {Promise}             that gets resolved once test/hook is done or was retried enough
- */
-export async function executeAsync(fn, retries, args = [], timeout = 20000) {
-    this.wdioRetries = retries.attempts;
-    try {
-        /**
-         * To prevent test failures due to timeout exceptions in Jasmine from overwriting test objects with subsequent values,
-         * we reduce the overall timeout by a constant known as TIME_BUFFER. TIME_BUFFER acts as a safety margin, allowing a small
-         * window of time for an operation to complete before triggering a timeout. This approach ensures that test results are handled
-         * properly without affecting the overall test execution timing.
-         */
-        // @ts-expect-error
-        const _timeout = (this?._runnable?._timeout || globalThis.jasmine?.DEFAULT_TIMEOUT_INTERVAL || timeout) - TIME_BUFFER;
-        /**
-         * Executes the function with specified timeout and returns the result, or throws an error if the timeout is exceeded.
-         */
-        let done = false;
-        const result = await Promise.race([
-            fn.apply(this, args),
-            new Promise((resolve, reject) => {
-                setTimeout(() => {
-                    if (done) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error('Timeout'));
-                    }
-                }, _timeout);
-            })
-        ]);
-        done = true;
-        if (result !== null && typeof result === 'object' && 'finally' in result && typeof result.finally === 'function') {
-            result.catch((err) => err);
-        }
-        return await result;
-    }
-    catch (err) {
-        if (retries.limit > retries.attempts) {
-            retries.attempts++;
-            return await executeAsync.call(this, fn, retries, args);
-        }
-        throw err;
-    }
-}

package/build/startWebDriver.js

@@ -1,20 +0,0 @@
-import logger from '@wdio/logger';
-import { definesRemoteDriver } from './utils.js';
-const log = logger('@wdio/utils');
-export async function startWebDriver(options) {
-    /**
-     * if any of the connection parameter are set, don't start any driver
-     */
-    if (definesRemoteDriver(options)) {
-        log.info(`Connecting to existing driver at ${options.protocol}://${options.hostname}:${options.port}${options.path}`);
-        return;
-    }
-    /**
-     * only import `startWebDriver` when run in Node.js
-     */
-    if (globalThis.process) {
-        const { startWebDriver } = await import('./node/index.js');
-        return startWebDriver(options);
-    }
-    throw new Error('Please provide a valid `hostname` and `port` to start WebDriver sessions in the browser!');
-}

package/build/test-framework/errorHandler.js

@@ -1,33 +0,0 @@
-/**
- * notify `WDIOCLInterface` about failure in hook
- * we need to do it this way because `beforeFn` and `afterFn` are not real hooks.
- * Otherwise hooks failures are lost.
- *
- * @param {string}  hookName    name of the hook
- * @param {Array}   hookResults hook functions results array
- * @param {string}  cid         cid
- */
-export const logHookError = (hookName, hookResults = [], cid) => {
-    const result = hookResults.find(result => result instanceof Error);
-    if (typeof result === 'undefined') {
-        return;
-    }
-    /**
-     * need to convert Error to plain object, otherwise it is lost on process.send
-     */
-    const error = { message: result.message };
-    const content = {
-        cid: cid,
-        error: error,
-        fullTitle: `${hookName} Hook`,
-        type: 'hook',
-        state: 'fail'
-    };
-    if (globalThis.process && typeof globalThis.process.send === 'function') {
-        globalThis.process.send({
-            origin: 'reporter',
-            name: 'printFailureMessage',
-            content
-        });
-    }
-};

package/build/test-framework/index.js

@@ -1,4 +0,0 @@
-/* istanbul ignore file */
-import { testFnWrapper } from './testFnWrapper.js';
-import { wrapGlobalTestMethod } from './testInterfaceWrapper.js';
-export { testFnWrapper, wrapGlobalTestMethod };

package/build/test-framework/testFnWrapper.js

@@ -1,97 +0,0 @@
-import { logHookError } from './errorHandler.js';
-import { executeHooksWithArgs, executeAsync } from '../shim.js';
-const STACKTRACE_FILTER = [
-    'node_modules/webdriver/',
-    'node_modules/webdriverio/',
-    'node_modules/@wdio/',
-    '(internal/process/task',
-    '(node:internal/process/task'
-];
-/**
- * wraps test framework spec/hook function with WebdriverIO before/after hooks
- *
- * @param   {string} type           Test/Step or Hook
- * @param   {object} spec           specFn and specFnArgs
- * @param   {object} before         beforeFn and beforeFnArgs
- * @param   {object} after          afterFn and afterFnArgs
- * @param   {string} cid            cid
- * @param   {number} repeatTest     number of retries if test fails
- * @param   {string} hookName       the hook name
- * @param   {number} timeout        the maximum time (in milliseconds) to wait for
- * @return  {*}                     specFn result
- */
-export const testFnWrapper = function (...args) {
-    return testFrameworkFnWrapper.call(this, { executeHooksWithArgs, executeAsync }, ...args);
-};
-/**
- * wraps test framework spec/hook function with WebdriverIO before/after hooks
- *
- * @param   {object} wrapFunctions  executeHooksWithArgs, executeAsync, runSync
- * @param   {string} type           Test/Step or Hook
- * @param   {object} spec           specFn and specFnArgs array
- * @param   {object} before         beforeFn and beforeFnArgs function
- * @param   {object} after          afterFn and afterFnArgs function
- * @param   {string} cid            cid
- * @param   {number} repeatTest     number of retries if test fails
- * @param   {string} hookName       the hook name
- * @param   {number} timeout        the maximum time (in milliseconds) to wait for
- * @return  {*}                     specFn result
- */
-export const testFrameworkFnWrapper = async function ({ executeHooksWithArgs, executeAsync }, type, { specFn, specFnArgs }, { beforeFn, beforeFnArgs }, { afterFn, afterFnArgs }, cid, repeatTest = 0, hookName, timeout) {
-    const retries = { attempts: 0, limit: repeatTest };
-    const beforeArgs = beforeFnArgs(this);
-    if (type === 'Hook' && hookName) {
-        beforeArgs.push(hookName);
-    }
-    await logHookError(`Before${type}`, await executeHooksWithArgs(`before${type}`, beforeFn, beforeArgs), cid);
-    let result;
-    let error;
-    const testStart = Date.now();
-    try {
-        result = await executeAsync.call(this, specFn, retries, specFnArgs, timeout);
-        if (globalThis._jasmineTestResult !== undefined) {
-            result = globalThis._jasmineTestResult;
-            globalThis._jasmineTestResult = undefined;
-        }
-        if (globalThis._wdioDynamicJasmineResultErrorList?.length > 0) {
-            globalThis._wdioDynamicJasmineResultErrorList[0].stack = filterStackTrace(globalThis._wdioDynamicJasmineResultErrorList[0].stack);
-            error = globalThis._wdioDynamicJasmineResultErrorList[0];
-            globalThis._wdioDynamicJasmineResultErrorList = undefined;
-        }
-    }
-    catch (err) {
-        if (err.stack) {
-            err.stack = filterStackTrace(err.stack);
-        }
-        error = err;
-    }
-    const duration = Date.now() - testStart;
-    const afterArgs = afterFnArgs(this);
-    afterArgs.push({
-        retries,
-        error,
-        result,
-        duration,
-        passed: !error
-    });
-    if (type === 'Hook' && hookName) {
-        afterArgs.push(hookName);
-    }
-    await logHookError(`After${type}`, await executeHooksWithArgs(`after${type}`, afterFn, [...afterArgs]), cid);
-    if (error && !error.matcherName) {
-        throw error;
-    }
-    return result;
-};
-/**
- * Filter out internal stacktraces. exporting to allow testing of the function
- * @param   {string} stack Stacktrace
- * @returns {string}
- */
-export const filterStackTrace = (stack) => {
-    return stack
-        .split('\n')
-        .filter(line => !STACKTRACE_FILTER.some(l => line.includes(l)))
-        .map(line => line.replace(/\?invalidateCache=(\d\.\d+|\d)/g, ''))
-        .join('\n');
-};

package/build/test-framework/testInterfaceWrapper.js

@@ -1,162 +0,0 @@
-/**
- * used to wrap mocha, jasmine test frameworks functions (`it`, `beforeEach` and other)
- * with WebdriverIO before/after Test/Hook hooks.
- * Entrypoint is `wrapGlobalTestMethod`, other functions are exported for testing purposes.
- *
- * NOTE: not used by cucumber test framework. `testFnWrapper` is called directly there
- */
-import { filterSpecArgs } from '../utils.js';
-import { testFnWrapper } from './testFnWrapper.js';
-const MOCHA_COMMANDS = ['skip', 'only'];
-/**
- * runs a hook and execute before/after hook
- *
- * @param  {Function} hookFn        function that was passed to the framework hook
- * @param  {Function} origFn        original framework hook function
- * @param  {Function} beforeFn      before hook
- * @param  {Function} beforeFnArgs  function that returns args for `beforeFn`
- * @param  {Function} afterFn       after hook
- * @param  {Function} afterArgsFn   function that returns args for `afterFn`
- * @param  {string}   cid           cid
- * @param  {number}   repeatTest    number of retries if hook fails
- * @return {Function}               wrapped framework hook function
- */
-export const runHook = function (hookFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
-    const wrappedHook = function (...hookFnArgs) {
-        return testFnWrapper.call(this, 'Hook', {
-            specFn: hookFn,
-            specFnArgs: filterSpecArgs(hookFnArgs)
-        }, {
-            beforeFn,
-            beforeFnArgs
-        }, {
-            afterFn,
-            afterFnArgs
-        }, cid, repeatTest, origFn.name);
-    };
-    /**
-     * make sure Mocha grabs the correct hook function body
-     */
-    wrappedHook.toString = () => hookFn.toString();
-    return origFn(wrappedHook, timeout);
-};
-/**
- * runs a spec function (test function)
- *
- * @param  {string}   specTitle     test description
- * @param  {Function} specFn        test function that got passed in from the user
- * @param  {Function} origFn        original framework test function
- * @param  {Function} beforeFn      before hook
- * @param  {Function} beforeFnArgs  function that returns args for `beforeFn`
- * @param  {Function} afterFn       after hook
- * @param  {Function} afterFnArgs   function that returns args for `afterFn`
- * @param  {string}   cid           cid
- * @param  {number}   repeatTest    number of retries if test fails
- * @return {Function}               wrapped test function
- */
-export const runSpec = function (specTitle, specFn, origFn, beforeFn, beforeFnArgs, afterFn, afterFnArgs, cid, repeatTest, timeout) {
-    const wrappedFn = function (...specFnArgs) {
-        return testFnWrapper.call(this, 'Test', {
-            specFn,
-            specFnArgs: filterSpecArgs(specFnArgs)
-        }, {
-            beforeFn,
-            beforeFnArgs
-        }, {
-            afterFn,
-            afterFnArgs
-        }, cid, repeatTest);
-    };
-    /**
-     * make sure Mocha grabs the correct test function body
-     */
-    wrappedFn.toString = () => specFn.toString();
-    return origFn(specTitle, wrappedFn, timeout);
-};
-/**
- * wraps hooks and test function of a framework within a fiber context
- *
- * @param  {Function} origFn               original framework function
- * @param  {Boolean}  isSpec               whether or not origFn is a spec
- * @param  {string[]} testInterfaceFnNames command that runs specs, e.g. `it`, `it.only` or `fit`
- * @param  {Function} beforeFn             before hook
- * @param  {Function} beforeFnArgs         function that returns args for `beforeFn`
- * @param  {Function} afterFn              after hook
- * @param  {Function} afterArgsFn          function that returns args for `afterFn`
- * @param  {string}   cid                  cid
- * @return {Function}                      wrapped test/hook function
- */
-export const wrapTestFunction = function (origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid) {
-    return function (...specArguments) {
-        /**
-         * Variadic arguments:
-         * [title, fn], [title], [fn]
-         * [title, fn, retryCnt], [title, retryCnt], [fn, retryCnt]
-         */
-        let retryCnt = typeof specArguments[specArguments.length - 1] === 'number'
-            ? specArguments.pop() :
-            0;
-        /**
-         * Jasmine uses a timeout value as last parameter, in this case the arguments
-         * should be [title, fn, timeout, retryCnt]
-         */
-        // @ts-expect-error
-        let timeout = globalThis.jasmine?.DEFAULT_TIMEOUT_INTERVAL;
-        // @ts-expect-error
-        if (globalThis.jasmine) {
-            // if we have [title, fn, timeout, retryCnt]
-            if (typeof specArguments[specArguments.length - 1] === 'number') {
-                timeout = specArguments.pop();
-                // if we have [title, fn, timeout]
-            }
-            else {
-                timeout = retryCnt;
-                retryCnt = 0;
-            }
-        }
-        const specFn = typeof specArguments[0] === 'function' ? specArguments.shift()
-            : (typeof specArguments[1] === 'function' ? specArguments[1] : undefined);
-        const specTitle = specArguments[0];
-        if (isSpec) {
-            if (specFn) {
-                return runSpec(specTitle, specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
-            }
-            /**
-             * if specFn is undefined we are dealing with a pending function
-             */
-            return origFn(specTitle);
-        }
-        return runHook(specFn, origFn, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid, retryCnt, timeout);
-    };
-};
-/**
- * Wraps global test function like `it`.
- *
- * The scope parameter is used in the qunit framework since all functions are bound to global.QUnit instead of global
- *
- * @param  {boolean}  isTest        is `origFn` test function, otherwise hook
- * @param  {Function} beforeFn      before hook
- * @param  {Function} beforeFnArgs  function that returns args for `beforeFn`
- * @param  {Function} afterFn       after hook
- * @param  {Function} afterArgsFn   function that returns args for `afterFn`
- * @param  {string}   fnName        test interface command to wrap, e.g. `beforeEach`
- * @param  {string}   cid           cid
- * @param  {Object}   scope         the scope to run command from, defaults to global
- */
-export const wrapGlobalTestMethod = function (isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, fnName, cid, scope = globalThis) {
-    const origFn = scope[fnName];
-    scope[fnName] = wrapTestFunction(origFn, isSpec, beforeFn, beforeArgsFn, afterFn, afterArgsFn, cid);
-    addMochaCommands(origFn, scope[fnName]);
-};
-/**
- * support `it.skip` and `it.only` for the Mocha framework
- * @param {Function} origFn original function
- * @param {function} newFn  wrapped function
- */
-function addMochaCommands(origFn, newFn) {
-    MOCHA_COMMANDS.forEach((commandName) => {
-        if (typeof origFn[commandName] === 'function') {
-            newFn[commandName] = origFn[commandName];
-        }
-    });
-}

package/build/test-framework/types.js

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