@wdio/browser-runner 9.0.0-alpha.78 → 9.0.0

package/build/vite/plugins/mockHoisting.js

@@ -1,312 +0,0 @@
-import os from 'node:os';
-import url from 'node:url';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import logger from '@wdio/logger';
-import { parse, print, visit, types } from 'recast';
-import typescriptParser from 'recast/parsers/typescript.js';
-const log = logger('@wdio/browser-runner:mockHoisting');
-const INTERNALS_TO_IGNORE = [
-    '@vite/client', 'vite/dist/client', '/webdriverio/build/', '/@wdio/', '/webdriverio/node_modules/',
-    'virtual:wdio', '?html-proxy', '/__fixtures__/', '/__mocks__/', '/.vite/deps/@testing-library_vue.js'
-];
-const b = types.builders;
-const MOCK_PREFIX = '/@mock';
-export function mockHoisting(mockHandler) {
-    let spec = null;
-    let isTestDependency = false;
-    const sessionMocks = new Set();
-    const importMap = new Map();
-    return [{
-            name: 'wdio:mockHoisting:pre',
-            enforce: 'pre',
-            resolveId: mockHandler.resolveId.bind(mockHandler),
-            load: async function (id) {
-                if (id.startsWith(MOCK_PREFIX)) {
-                    try {
-                        const orig = await fs.readFile(id.slice(MOCK_PREFIX.length + (os.platform() === 'win32' ? 1 : 0)));
-                        return orig.toString();
-                    }
-                    catch (err) {
-                        log.error(`Failed to read file (${id}) for mocking: ${err.message}`);
-                        return '';
-                    }
-                }
-            }
-        }, {
-            name: 'wdio:mockHoisting',
-            enforce: 'post',
-            transform(code, id) {
-                const isSpecFile = id === spec;
-                if (isSpecFile) {
-                    isTestDependency = true;
-                }
-                /**
-                 * only transform files:
-                 */
-                if (
-                // where loading was inititated through the test file
-                (!isTestDependency && (
-                // however when files are inlined they will be loaded when parsing file under test
-                // in this case we want to transform them, but make sure we exclude these paths
-                id.includes('/node_modules/') || id.includes('/?cid=') || id.startsWith('virtual:'))) ||
-                    // are not Vite or WebdriverIO internals
-                    INTERNALS_TO_IGNORE.find((f) => id.includes(f)) ||
-                    // when the spec file is actually mocking any dependencies
-                    (!isSpecFile && sessionMocks.size === 0)) {
-                    return { code };
-                }
-                let ast;
-                const start = Date.now();
-                try {
-                    ast = parse(code, {
-                        parser: typescriptParser,
-                        sourceFileName: id,
-                        sourceRoot: path.dirname(id)
-                    });
-                    log.trace(`Parsed file for mocking: ${id} in ${Date.now() - start}ms`);
-                }
-                catch (err) {
-                    return { code };
-                }
-                let importIndex = 0;
-                let mockFunctionName;
-                let unmockFunctionName;
-                const mockCalls = [];
-                visit(ast, {
-                    /**
-                     * find function name for mock and unmock calls
-                     */
-                    visitImportDeclaration: function (path) {
-                        const dec = path.value;
-                        const source = dec.source.value;
-                        if (!dec.specifiers || dec.specifiers.length === 0 || source !== '@wdio/browser-runner') {
-                            return this.traverse(path);
-                        }
-                        /**
-                         * get name of mock function variable
-                         */
-                        const mockSpecifier = dec.specifiers
-                            .filter((s) => s.type === types.namedTypes.ImportSpecifier.toString())
-                            .find((s) => s.imported.name === 'mock');
-                        if (mockSpecifier && mockSpecifier.local) {
-                            mockFunctionName = mockSpecifier.local.name;
-                        }
-                        const unmockSpecifier = dec.specifiers
-                            .filter((s) => s.type === types.namedTypes.ImportSpecifier.toString())
-                            .find((s) => s.imported.name === 'unmock');
-                        if (unmockSpecifier && unmockSpecifier.local) {
-                            unmockFunctionName = unmockSpecifier.local.name;
-                        }
-                        mockCalls.push(dec);
-                        path.prune();
-                        return this.traverse(path);
-                    },
-                    /**
-                     * detect which modules are supposed to be mocked
-                     */
-                    ...(isSpecFile ? {
-                        visitExpressionStatement: function (path) {
-                            const exp = path.value;
-                            if (exp.expression.type !== types.namedTypes.CallExpression.toString()) {
-                                return this.traverse(path);
-                            }
-                            const callExp = exp.expression;
-                            const isUnmockCall = unmockFunctionName && callExp.callee.name === unmockFunctionName;
-                            const isMockCall = mockFunctionName && callExp.callee.name === mockFunctionName;
-                            if (!isMockCall && !isUnmockCall) {
-                                return this.traverse(path);
-                            }
-                            /**
-                             * hoist unmock calls
-                             */
-                            if (isUnmockCall && callExp.arguments[0] && typeof callExp.arguments[0].value === 'string') {
-                                mockHandler.unmock(callExp.arguments[0].value);
-                            }
-                            else if (isMockCall) {
-                                /**
-                                 * if only one mock argument is set, we take the fixture from the automock directory
-                                 */
-                                const mockCall = exp.expression;
-                                if (mockCall.arguments.length === 1) {
-                                    /**
-                                     * enable manual mock
-                                     */
-                                    mockHandler.manualMocks.push(mockCall.arguments[0].value);
-                                }
-                                else {
-                                    if (exp.expression.arguments.length) {
-                                        sessionMocks.add(exp.expression.arguments[0].value);
-                                    }
-                                    /**
-                                     * hoist mock calls
-                                     */
-                                    mockCalls.push(exp);
-                                }
-                            }
-                            path.prune();
-                            this.traverse(path);
-                        }
-                    } : {})
-                });
-                visit(ast, {
-                    /**
-                     * rewrite import statements
-                     */
-                    visitImportDeclaration: function (nodePath) {
-                        const dec = nodePath.value;
-                        const source = dec.source.value;
-                        if (!dec.specifiers || dec.specifiers.length === 0) {
-                            return this.traverse(nodePath);
-                        }
-                        const newImportIdentifier = `__wdio_import${importIndex++}`;
-                        const isMockedModule = Boolean(
-                        // matches if a dependency is mocked
-                        sessionMocks.has(source) ||
-                            // matches if a relative file is mocked
-                            (source.startsWith('.') &&
-                                [...sessionMocks.values()].find((m) => {
-                                    const fileImportPath = path.resolve(path.dirname(id), source);
-                                    const fileImportPathSliced = fileImportPath.slice(0, path.extname(fileImportPath).length * -1);
-                                    const testMockPath = path.resolve(path.dirname(spec || '/'), m);
-                                    const testMockPathSliced = testMockPath.slice(0, path.extname(testMockPath).length * -1);
-                                    return fileImportPathSliced === testMockPathSliced && fileImportPathSliced.length > 0;
-                                })));
-                        /**
-                         * add to import map if module is mocked and imported in the test file
-                         */
-                        if (isMockedModule && isSpecFile) {
-                            importMap.set(source, newImportIdentifier);
-                        }
-                        /**
-                         * Assign imports outside of spec files or when module gets mocked
-                         * into custom import identifier, e.g.
-                         *
-                         *   from:
-                         *      import { foo } from 'bar'
-                         *
-                         *   to:
-                         *      import * as __wdio_import0 from 'bar'
-                         */
-                        if (!isSpecFile || isMockedModule) {
-                            const newNode = b.importDeclaration([b.importNamespaceSpecifier(b.identifier(newImportIdentifier))], b.literal(source));
-                            mockCalls.unshift(newNode);
-                        }
-                        // determine file extension length so we can cut it out, fall back to infinity if no extension is set
-                        const mockExtensionLengh = (path.extname(source).length * -1) || Infinity;
-                        const wdioImportModuleIdentifier = source.startsWith('.') || source.startsWith('/')
-                            ? url.pathToFileURL(path.resolve(path.dirname(id), source).slice(0, mockExtensionLengh)).pathname
-                            : source;
-                        const isNamespaceImport = dec.specifiers.length === 1 && dec.specifiers[0].type === types.namedTypes.ImportNamespaceSpecifier.toString();
-                        const mockImport = isSpecFile && !isMockedModule
-                            /**
-                             * within spec files we transform import declarations into import expresssions, e.g.
-                             *     from: import { foo } from 'bar'
-                             *     to:   const { foo } = await wdioImport('bar', await import('bar'))
-                             *
-                             * in order to hoist `mock(...)` calls and have them run first
-                             */
-                            ? b.variableDeclaration('const', [
-                                b.variableDeclarator(isNamespaceImport
-                                    /**
-                                     * we deal with a ImportNamespaceSpecifier, e.g.:
-                                     * import * as foo from 'bar'
-                                     */
-                                    ? dec.specifiers[0].local
-                                    /**
-                                     * we deal with default or named import, e.g.
-                                     * import foo from 'bar'
-                                     * or
-                                     * import { foo } from 'bar'
-                                     */
-                                    : b.objectPattern(dec.specifiers.map((s) => {
-                                        if (s.type === types.namedTypes.ImportDefaultSpecifier.toString()) {
-                                            return b.property('init', b.identifier('default'), b.identifier(s.local.name));
-                                        }
-                                        return b.property('init', b.identifier(s.imported.name), b.identifier(s.local.name));
-                                    })), b.awaitExpression(b.importExpression(b.literal(source))))
-                            ])
-                            /**
-                             * outside of spec files we transform import declarations so that the imported module gets
-                             * wrapped within `wdioImport`, e.g.:
-                             *
-                             *   from:
-                             *      import { foo } from 'bar'
-                             *
-                             *   to:
-                             *      import { foo as __wdio_import0 } from 'bar'
-                             *      const { foo } = await wdioImport('bar', __wdio_import0)
-                             */
-                            : b.variableDeclaration('const', [
-                                b.variableDeclarator(dec.specifiers.length === 1 && dec.specifiers[0].type === types.namedTypes.ImportNamespaceSpecifier.toString()
-                                    ? b.identifier(dec.specifiers[0].local.name)
-                                    : b.objectPattern(dec.specifiers.map((s) => {
-                                        if (s.type === types.namedTypes.ImportDefaultSpecifier.toString()) {
-                                            return b.property('init', b.identifier('default'), b.identifier(s.local.name));
-                                        }
-                                        return b.property('init', b.identifier(s.imported.name), b.identifier(s.local.name));
-                                    })), b.callExpression(b.identifier('wdioImport'), [
-                                    b.literal(wdioImportModuleIdentifier),
-                                    b.identifier(newImportIdentifier)
-                                ]))
-                            ]);
-                        nodePath.replace(mockImport);
-                        this.traverse(nodePath);
-                    }
-                });
-                ast.program.body.unshift(...mockCalls.map((mc) => {
-                    const exp = mc;
-                    if (exp.expression && exp.expression.type === types.namedTypes.CallExpression.toString()) {
-                        const mockCallExpression = exp.expression;
-                        const mockedModule = mockCallExpression.arguments[0].value;
-                        const mockFactory = mockCallExpression.arguments[1];
-                        /**
-                         * add actual module as 3rd parameter to the mock call if imported in the same test file
-                         */
-                        if (importMap.has(mockedModule)) {
-                            mockCallExpression.arguments.push(b.identifier(importMap.get(mockedModule)));
-                        }
-                        else if (mockFactory.params.length > 0) {
-                            /**
-                             * `importMap` only has an entry if the module is imported in the same test file.
-                             * However if the user mocks a dependency of a different dependency we need to add
-                             * the import manually if the users wants to access the original module.
-                             */
-                            const newImportIdentifier = `__wdio_import${importIndex++}`;
-                            ast.program.body.unshift(b.importDeclaration([b.importNamespaceSpecifier(b.identifier(newImportIdentifier))], b.literal(mockedModule)));
-                            mockCallExpression.arguments.push(b.identifier(newImportIdentifier));
-                        }
-                        return b.expressionStatement(b.awaitExpression(mockCallExpression));
-                    }
-                    return mc;
-                }));
-                try {
-                    const newCode = print(ast, { sourceMapName: id });
-                    log.trace(`Transformed file for mocking: ${id} in ${Date.now() - start}ms`);
-                    return newCode;
-                }
-                catch (err) {
-                    log.trace(`Failed to transformed file (${id}) for mocking: ${err.stack}`);
-                    return { code };
-                }
-            },
-            configureServer(server) {
-                return () => {
-                    server.middlewares.use('/', async (req, res, next) => {
-                        if (!req.originalUrl) {
-                            return next();
-                        }
-                        const urlParsed = url.parse(req.originalUrl);
-                        const urlParamString = new URLSearchParams(urlParsed.query || '');
-                        const specParam = urlParamString.get('spec');
-                        if (specParam) {
-                            mockHandler.resetMocks();
-                            isTestDependency = false;
-                            spec = os.platform() === 'win32' ? specParam.slice(1) : specParam;
-                        }
-                        return next();
-                    });
-                };
-            }
-        }];
-}

package/build/vite/plugins/testrunner.js

@@ -1,152 +0,0 @@
-import url from 'node:url';
-import path from 'node:path';
-import { builtinModules } from 'node:module';
-import logger from '@wdio/logger';
-import { polyfillPath } from 'modern-node-polyfills';
-import { deepmerge } from 'deepmerge-ts';
-import { resolve } from 'import-meta-resolve';
-import { WebDriverProtocol, MJsonWProtocol, AppiumProtocol, ChromiumProtocol, SauceLabsProtocol, SeleniumProtocol, GeckoProtocol } from '@wdio/protocols';
-import { SESSIONS } from '../../constants.js';
-import { getTemplate, getErrorTemplate, normalizeId } from '../utils.js';
-const log = logger('@wdio/browser-runner:plugin');
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
-const commands = deepmerge(WebDriverProtocol, MJsonWProtocol, AppiumProtocol, ChromiumProtocol, SauceLabsProtocol, SeleniumProtocol, GeckoProtocol);
-const protocolCommandList = Object.values(commands).map((endpoint) => Object.values(endpoint).map(({ command }) => command)).flat();
-const WDIO_PACKAGES = ['webdriverio', 'expect-webdriverio'];
-const virtualModuleId = 'virtual:wdio';
-const resolvedVirtualModuleId = '\0' + virtualModuleId;
-/**
- * these modules are used in Node.js environments only and
- * don't need to be compiled, we just have them point to a
- * mocked module that returns a matching interface without
- * functionality
- */
-const MODULES_TO_MOCK = [
-    'import-meta-resolve', 'puppeteer-core', 'archiver', 'glob', 'ws', 'decamelize',
-    'geckodriver', 'safaridriver', 'edgedriver', '@puppeteer/browsers', 'locate-app', 'wait-port',
-    'lodash.isequal', '@wdio/repl'
-];
-const POLYFILLS = [
-    ...builtinModules,
-    ...builtinModules.map((m) => `node:${m}`)
-];
-export function testrunner(options) {
-    const browserModules = path.resolve(__dirname, '..', '..', 'browser');
-    const automationProtocolPath = `/@fs${url.pathToFileURL(path.resolve(browserModules, 'driver.js')).pathname}`;
-    const mockModulePath = path.resolve(browserModules, 'mock.js');
-    const setupModulePath = path.resolve(browserModules, 'setup.js');
-    const spyModulePath = path.resolve(browserModules, 'spy.js');
-    const wdioExpectModulePath = path.resolve(browserModules, 'expect.js');
-    return [{
-            name: 'wdio:testrunner',
-            enforce: 'pre',
-            resolveId: async (id) => {
-                if (id === virtualModuleId) {
-                    return resolvedVirtualModuleId;
-                }
-                if (POLYFILLS.includes(id)) {
-                    return polyfillPath(normalizeId(id.replace('/promises', '')));
-                }
-                /**
-                 * fake the content of this package and load the implementation of the mock
-                 * features from the browser module directory
-                 */
-                if (id === '@wdio/browser-runner') {
-                    return spyModulePath;
-                }
-                /**
-                 * allow to load the setup script from a script tag
-                 */
-                if (id.endsWith('@wdio/browser-runner/setup')) {
-                    return setupModulePath;
-                }
-                /**
-                 * run WebdriverIO assertions within the Node.js context so we can do things like
-                 * visual assertions or snapshot testing
-                 */
-                if (id === 'expect-webdriverio') {
-                    return wdioExpectModulePath;
-                }
-                /**
-                 * make sure WDIO imports are resolved properly as ESM module
-                 */
-                if (id.startsWith('@wdio') || WDIO_PACKAGES.includes(id)) {
-                    return url.fileURLToPath(await resolve(id, import.meta.url));
-                }
-                /**
-                 * mock out imports that we can't transpile into browser land
-                 */
-                if (MODULES_TO_MOCK.includes(id)) {
-                    return mockModulePath;
-                }
-            },
-            load(id) {
-                /**
-                 * provide a list of protocol commands to generate the prototype in the browser
-                 */
-                if (id === resolvedVirtualModuleId) {
-                    return /*js*/ `
-                    import { fn } from '@wdio/browser-runner'
-                    export const commands = ${JSON.stringify(protocolCommandList)}
-                    export const automationProtocolPath = ${JSON.stringify(automationProtocolPath)}
-                    export const wrappedFn = (...args) => fn()(...args)
-                `;
-                }
-            },
-            transform(code, id) {
-                if (id.includes('.vite/deps/expect.js')) {
-                    return {
-                        code: code.replace('var fs = _interopRequireWildcard(require_graceful_fs());', 'var fs = {};').replace('var expect_default = require_build11();', 'var expect_default = require_build11();\nwindow.expect = expect_default.default;').replace('process.stdout.isTTY', 'false')
-                    };
-                }
-                return { code };
-            },
-            configureServer(server) {
-                return () => {
-                    server.middlewares.use(async (req, res, next) => {
-                        log.info(`Received request for: ${req.originalUrl}`);
-                        /**
-                         * don't return test page when sourcemaps are requested
-                         */
-                        if (!req.originalUrl || req.url?.endsWith('.map') || req.url?.endsWith('.wasm')) {
-                            return next();
-                        }
-                        const cookies = ((req.headers.cookie && req.headers.cookie.split(';')) || []).map((c) => c.trim());
-                        const urlParsed = url.parse(req.originalUrl);
-                        const urlParamString = new URLSearchParams(urlParsed.query || '');
-                        const cid = urlParamString.get('cid') || cookies.find((c) => c.includes('WDIO_CID'))?.split('=').pop();
-                        const spec = urlParamString.get('spec') || cookies.find((c) => c.includes('WDIO_SPEC'))?.split('=').pop();
-                        if (!cid || !SESSIONS.has(cid)) {
-                            log.error(`No environment found for ${cid || 'non determined environment'}`);
-                            return next();
-                        }
-                        if (!spec) {
-                            log.error('No spec file was defined to run for this environment');
-                            return next();
-                        }
-                        const env = SESSIONS.get(cid);
-                        try {
-                            const template = await getTemplate(options, env, spec);
-                            log.debug(`Render template for ${req.originalUrl}`);
-                            res.end(await server.transformIndexHtml(`${req.originalUrl}`, template));
-                        }
-                        catch (err) {
-                            const template = getErrorTemplate(req.originalUrl, err);
-                            log.error(`Failed to render template: ${err.message}`);
-                            res.end(await server.transformIndexHtml(`${req.originalUrl}`, template));
-                        }
-                        return next();
-                    });
-                };
-            }
-        }, {
-            name: 'modern-node-polyfills',
-            async resolveId(id, _, ctx) {
-                if (ctx.ssr || !builtinModules.includes(id)) {
-                    return;
-                }
-                id = normalizeId(id);
-                return { id: await polyfillPath(id), moduleSideEffects: false };
-            },
-        }];
-}

package/build/vite/plugins/worker.js

@@ -1,12 +0,0 @@
-import { WDIO_EVENT_NAME } from '../../constants.js';
-/**
- * a Vite plugin to help communicate with the worker process
- */
-export function workerPlugin(onSocketEvent) {
-    return {
-        name: 'wdio:worker',
-        configureServer({ ws }) {
-            ws.on(WDIO_EVENT_NAME, onSocketEvent);
-        }
-    };
-}

package/build/vite/server.js

@@ -1,104 +0,0 @@
-import path from 'node:path';
-import { EventEmitter } from 'node:events';
-import getPort from 'get-port';
-import logger from '@wdio/logger';
-import istanbulPlugin from 'vite-plugin-istanbul';
-import { deepmerge } from 'deepmerge-ts';
-import { createServer } from 'vite';
-import { testrunner } from './plugins/testrunner.js';
-import { mockHoisting } from './plugins/mockHoisting.js';
-import { workerPlugin } from './plugins/worker.js';
-import { userfriendlyImport } from './utils.js';
-import { MockHandler } from './mock.js';
-import { PRESET_DEPENDENCIES, DEFAULT_VITE_CONFIG } from './constants.js';
-import { DEFAULT_INCLUDE, DEFAULT_FILE_EXTENSIONS } from '../constants.js';
-const log = logger('@wdio/browser-runner:ViteServer');
-const DEFAULT_CONFIG_ENV = {
-    command: 'serve',
-    mode: process.env.NODE_ENV === 'production' ? 'production' : 'development'
-};
-/**
- * Class that sets up the Vite server with correct configuration based on given WebdriverIO options.
- */
-export class ViteServer extends EventEmitter {
-    #options;
-    #config;
-    #viteConfig;
-    #server;
-    #mockHandler;
-    #socketEventHandler = [];
-    get config() {
-        return this.#viteConfig;
-    }
-    constructor(options, config, optimizations) {
-        super();
-        this.#options = options;
-        this.#config = config;
-        this.#mockHandler = new MockHandler(options, config);
-        const root = options.rootDir || config.rootDir || process.cwd();
-        this.#viteConfig = deepmerge(DEFAULT_VITE_CONFIG, optimizations, {
-            root,
-            plugins: [
-                testrunner(options),
-                mockHoisting(this.#mockHandler),
-                workerPlugin((payload, client) => (this.#socketEventHandler.forEach((handler) => handler(payload, client))))
-            ]
-        });
-        if (options.coverage && options.coverage.enabled) {
-            log.info('Capturing test coverage enabled');
-            // @ts-expect-error istanbul plugin seems to incorrectly export
-            // its type for our setup
-            const plugin = istanbulPlugin;
-            this.#viteConfig.plugins?.push(plugin({
-                cwd: config.rootDir,
-                include: DEFAULT_INCLUDE,
-                extension: DEFAULT_FILE_EXTENSIONS,
-                forceBuildInstrument: true,
-                ...options.coverage
-            }));
-        }
-    }
-    onBrowserEvent(handler) {
-        this.#socketEventHandler.push(handler);
-    }
-    async start() {
-        const vitePort = await getPort();
-        this.#viteConfig = deepmerge(this.#viteConfig, {
-            server: {
-                host: '0.0.0.0',
-                port: vitePort
-            }
-        });
-        /**
-         * load additional Vite plugins for framework
-         */
-        if (this.#options.preset) {
-            const [pkg, importProp, opts] = PRESET_DEPENDENCIES[this.#options.preset] || [];
-            const plugin = (await userfriendlyImport(this.#options.preset, pkg))[importProp || 'default'];
-            if (plugin) {
-                this.#viteConfig.plugins.push(plugin(opts));
-            }
-        }
-        /**
-         * merge custom `viteConfig` last into the object
-         */
-        if (this.#options.viteConfig) {
-            const { plugins, ...configToMerge } = typeof this.#options.viteConfig === 'string'
-                ? (await import(path.resolve(this.#config.rootDir || process.cwd(), this.#options.viteConfig))).default
-                : typeof this.#options.viteConfig === 'function'
-                    ? await this.#options.viteConfig(DEFAULT_CONFIG_ENV)
-                    : this.#options.viteConfig;
-            this.#viteConfig = deepmerge(this.#viteConfig, configToMerge);
-            this.#viteConfig.plugins = [...(plugins || []), ...this.#viteConfig.plugins];
-        }
-        /**
-         * initialize Vite
-         */
-        this.#server = await createServer(this.#viteConfig);
-        await this.#server.listen();
-        log.info(`Vite server started successfully on port ${vitePort}, root directory: ${this.#viteConfig.root}`);
-    }
-    async close() {
-        await this.#server?.close();
-    }
-}

package/build/vite/types.js

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