@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/browser-webdriverio/index.js

@@ -0,0 +1,600 @@
+import { parseKeyDef, resolveScreenshotPath, defineBrowserProvider } from '../browser/index.js';
+export { defineBrowserCommand } from '../browser/index.js';
+import { createDebugger } from '../../node.js';
+import { Key } from 'webdriverio';
+import crypto from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { normalize as normalize$1 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+const clear = async (context, selector) => {
+  const browser = context.browser;
+  await browser.$(selector).clearValue();
+};
+
+const click = async (context, selector, options) => {
+  const browser = context.browser;
+  await browser.$(selector).click(options);
+};
+const dblClick = async (context, selector, _options) => {
+  const browser = context.browser;
+  await browser.$(selector).doubleClick();
+};
+const tripleClick = async (context, selector, _options) => {
+  const browser = context.browser;
+  await browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: browser.$(selector) }).down().up().pause(50).down().up().pause(50).down().up().pause(50).perform();
+};
+
+const dragAndDrop = async (context, source, target, options_) => {
+  const $source = context.browser.$(source);
+  const $target = context.browser.$(target);
+  const options = options_ || {};
+  const duration = options.duration ?? 10;
+  // https://github.com/webdriverio/webdriverio/issues/8022#issuecomment-1700919670
+  await context.browser.action("pointer").move({
+    duration: 0,
+    origin: $source,
+    x: options.sourceX ?? 0,
+    y: options.sourceY ?? 0
+  }).down({ button: 0 }).move({
+    duration: 0,
+    origin: "pointer",
+    x: 0,
+    y: 0
+  }).pause(duration).move({
+    duration: 0,
+    origin: $target,
+    x: options.targetX ?? 0,
+    y: options.targetY ?? 0
+  }).move({
+    duration: 0,
+    origin: "pointer",
+    x: 1,
+    y: 0
+  }).move({
+    duration: 0,
+    origin: "pointer",
+    x: -1,
+    y: 0
+  }).up({ button: 0 }).perform();
+};
+
+const fill = async (context, selector, text, _options = {}) => {
+  const browser = context.browser;
+  await browser.$(selector).setValue(text);
+};
+
+const hover = async (context, selector, options = {}) => {
+  const browser = context.browser;
+  await browser.$(selector).moveTo(options);
+};
+
+const keyboard = async (context, text, state) => {
+  await context.browser.execute(focusIframe);
+  const pressed = new Set(state.unreleased);
+  await keyboardImplementation(pressed, context.provider, context.sessionId, text, async () => {
+    await context.browser.execute(selectAll);
+  }, true);
+  return { unreleased: Array.from(pressed) };
+};
+const keyboardCleanup = async (context, state) => {
+  if (!state.unreleased) {
+    return;
+  }
+  const keyboard = context.browser.action("key");
+  for (const key of state.unreleased) {
+    keyboard.up(key);
+  }
+  await keyboard.perform();
+};
+async function keyboardImplementation(pressed, provider, _sessionId, text, selectAll, skipRelease) {
+  const browser = provider.browser;
+  const actions = parseKeyDef(text);
+  let keyboard = browser.action("key");
+  for (const { releasePrevious, releaseSelf, repeat, keyDef } of actions) {
+    let key = keyDef.key;
+    const special = Key[key];
+    if (special) {
+      key = special;
+    }
+    if (pressed.has(key)) {
+      keyboard.up(key);
+      pressed.delete(key);
+    }
+    if (!releasePrevious) {
+      if (key === "selectall") {
+        await keyboard.perform();
+        keyboard = browser.action("key");
+        await selectAll();
+        continue;
+      }
+      for (let i = 1; i <= repeat; i++) {
+        keyboard.down(key);
+      }
+      if (releaseSelf) {
+        keyboard.up(key);
+      } else {
+        pressed.add(key);
+      }
+    }
+  }
+  // seems like webdriverio doesn't release keys automatically if skipRelease is true and all events are keyUp
+  const allRelease = keyboard.toJSON().actions.every((action) => action.type === "keyUp");
+  await keyboard.perform(allRelease ? false : skipRelease);
+  return { pressed };
+}
+function focusIframe() {
+  if (!document.activeElement || document.activeElement.ownerDocument !== document || document.activeElement === document.body) {
+    window.focus();
+  }
+}
+function selectAll() {
+  const element = document.activeElement;
+  if (element && typeof element.select === "function") {
+    element.select();
+  }
+}
+
+/**
+* Takes a screenshot using the provided browser context and returns a buffer and the expected screenshot path.
+*
+* **Note**: the returned `path` indicates where the screenshot *might* be found.
+* It is not guaranteed to exist, especially if `options.save` is `false`.
+*
+* @throws {Error} If the function is not called within a test or if the browser provider does not support screenshots.
+*/
+async function takeScreenshot(context, name, options) {
+  if (!context.testPath) {
+    throw new Error(`Cannot take a screenshot without a test path`);
+  }
+  const path = resolveScreenshotPath(context.testPath, name, context.project.config, options.path);
+  // playwright does not need a screenshot path if we don't intend to save it
+  let savePath;
+  if (options.save) {
+    savePath = normalize(path);
+    await mkdir(dirname(savePath), { recursive: true });
+  }
+  // webdriverio needs a path, so if one is not already set we create a temporary one
+  if (savePath === undefined) {
+    savePath = resolve(context.project.tmpDir, crypto.randomUUID());
+    await mkdir(context.project.tmpDir, { recursive: true });
+  }
+  const page = context.browser;
+  const element = !options.element ? await page.$("body") : await page.$(`${options.element}`);
+  // webdriverio expects the path to contain the extension and only works with PNG files
+  const savePathWithExtension = savePath.endsWith(".png") ? savePath : `${savePath}.png`;
+  // there seems to be a bug in webdriverio, `X:/` gets appended to cwd, so we convert to `X:\`
+  const buffer = await element.saveScreenshot(normalize$1(savePathWithExtension));
+  if (!options.save) {
+    await rm(savePathWithExtension, { force: true });
+  }
+  return {
+    buffer,
+    path
+  };
+}
+
+const selectOptions = async (context, selector, userValues, _options = {}) => {
+  const values = userValues;
+  if (!values.length) {
+    return;
+  }
+  const browser = context.browser;
+  if (values.length === 1 && "index" in values[0]) {
+    const selectElement = browser.$(selector);
+    await selectElement.selectByIndex(values[0].index);
+  } else {
+    throw new Error("Provider \"webdriverio\" doesn't support selecting multiple values at once");
+  }
+};
+
+const tab = async (context, options = {}) => {
+  const browser = context.browser;
+  await browser.keys(options.shift === true ? [Key.Shift, Key.Tab] : [Key.Tab]);
+};
+
+const type = async (context, selector, text, options = {}) => {
+  const { skipClick = false, skipAutoClose = false } = options;
+  const unreleased = new Set(Reflect.get(options, "unreleased") ?? []);
+  const browser = context.browser;
+  const element = browser.$(selector);
+  if (!skipClick && !await element.isFocused()) {
+    await element.click();
+  }
+  await keyboardImplementation(unreleased, context.provider, context.sessionId, text, () => browser.execute(() => {
+    const element = document.activeElement;
+    if (element && typeof element.select === "function") {
+      element.select();
+    }
+  }), skipAutoClose);
+  return { unreleased: Array.from(unreleased) };
+};
+
+const upload = async (context, selector, files, _options) => {
+  const testPath = context.testPath;
+  if (!testPath) {
+    throw new Error(`Cannot upload files outside of a test`);
+  }
+  const root = context.project.config.root;
+  for (const file of files) {
+    if (typeof file !== "string") {
+      throw new TypeError(`The "${context.provider.name}" provider doesn't support uploading files objects. Provide a file path instead.`);
+    }
+  }
+  const element = context.browser.$(selector);
+  for (const file of files) {
+    const filepath = resolve(root, file);
+    const remoteFilePath = await context.browser.uploadFile(filepath);
+    await element.addValue(remoteFilePath);
+  }
+};
+
+const viewport = async (context, options) => {
+  await context.provider.setViewport(options);
+};
+
+var commands = {
+  __vitest_upload: upload,
+  __vitest_click: click,
+  __vitest_dblClick: dblClick,
+  __vitest_tripleClick: tripleClick,
+  __vitest_takeScreenshot: takeScreenshot,
+  __vitest_type: type,
+  __vitest_clear: clear,
+  __vitest_fill: fill,
+  __vitest_tab: tab,
+  __vitest_keyboard: keyboard,
+  __vitest_selectOptions: selectOptions,
+  __vitest_dragAndDrop: dragAndDrop,
+  __vitest_hover: hover,
+  __vitest_cleanup: keyboardCleanup,
+  __vitest_viewport: viewport
+};
+
+const distRoot = dirname(fileURLToPath(import.meta.url));
+
+const debug = createDebugger("vitest:browser:wdio");
+const webdriverBrowsers = [
+  "firefox",
+  "chrome",
+  "edge",
+  "safari"
+];
+function webdriverio(options = {}) {
+  return defineBrowserProvider({
+    name: "webdriverio",
+    supportedBrowser: webdriverBrowsers,
+    options,
+    providerFactory(project) {
+      return new WebdriverBrowserProvider(project, options);
+    }
+  });
+}
+class WebdriverBrowserProvider {
+  name = "webdriverio";
+  supportsParallelism = false;
+  browser = null;
+  browserName;
+  project;
+  options;
+  closing = false;
+  iframeSwitched = false;
+  topLevelContext;
+  initScripts = [resolve(distRoot, "locators.js")];
+  getSupportedBrowsers() {
+    return webdriverBrowsers;
+  }
+  constructor(project, options) {
+    // increase shutdown timeout because WDIO takes some extra time to kill the driver
+    if (!project.vitest.state._data.timeoutIncreased) {
+      project.vitest.state._data.timeoutIncreased = true;
+      project.vitest.config.teardownTimeout += 1e4;
+    }
+    this.closing = false;
+    this.project = project;
+    this.browserName = project.config.browser.name;
+    this.options = options;
+    for (const [name, command] of Object.entries(commands)) {
+      project.browser.registerCommand(name, command);
+    }
+  }
+  isIframeSwitched() {
+    return this.iframeSwitched;
+  }
+  async switchToTestFrame() {
+    const browser = this.browser;
+    // support wdio@9
+    if (browser.switchFrame) {
+      await browser.switchFrame(browser.$("iframe[data-vitest]"));
+    } else {
+      const iframe = await browser.findElement("css selector", "iframe[data-vitest]");
+      await browser.switchToFrame(iframe);
+    }
+    this.iframeSwitched = true;
+  }
+  async switchToMainFrame() {
+    const page = this.browser;
+    if (page.switchFrame) {
+      await page.switchFrame(null);
+    } else {
+      await page.switchToParentFrame();
+    }
+    this.iframeSwitched = false;
+  }
+  async setViewport(options) {
+    if (this.topLevelContext == null || !this.browser) {
+      throw new Error(`The browser has no open pages.`);
+    }
+    if (this.browser.isBidi) {
+      await this.browser.send({
+        method: "browsingContext.setViewport",
+        params: {
+          context: this.topLevelContext,
+          devicePixelRatio: 1,
+          viewport: options
+        }
+      });
+    } else {
+      await this.browser.setWindowSize(options.width, options.height);
+    }
+  }
+  getCommandsContext() {
+    return { browser: this.browser };
+  }
+  async openBrowser() {
+    await this._throwIfClosing("opening the browser");
+    if (this.browser) {
+      debug?.("[%s] the browser is already opened, reusing it", this.browserName);
+      return this.browser;
+    }
+    const options = this.project.config.browser;
+    if (this.browserName === "safari") {
+      if (options.headless) {
+        throw new Error("You've enabled headless mode for Safari but it doesn't currently support it.");
+      }
+    }
+    const { remote } = await import('webdriverio');
+    const remoteOptions = {
+      logLevel: "silent",
+      ...this.options,
+      capabilities: this.buildCapabilities()
+    };
+    debug?.("[%s] opening the browser with options: %O", this.browserName, remoteOptions);
+    // TODO: close everything, if browser is closed from the outside
+    this.browser = await remote(remoteOptions);
+    await this._throwIfClosing();
+    return this.browser;
+  }
+  buildCapabilities() {
+    const capabilities = {
+      ...this.options?.capabilities,
+      browserName: this.browserName
+    };
+    const headlessMap = {
+      chrome: ["goog:chromeOptions", ["headless", "disable-gpu"]],
+      firefox: ["moz:firefoxOptions", ["-headless"]],
+      edge: ["ms:edgeOptions", ["--headless"]]
+    };
+    const options = this.project.config.browser;
+    const browser = this.browserName;
+    if (browser !== "safari" && options.headless) {
+      const [key, args] = headlessMap[browser];
+      const currentValues = (this.options?.capabilities)?.[key] || {};
+      const newArgs = [...currentValues.args || [], ...args];
+      capabilities[key] = {
+        ...currentValues,
+        args: newArgs
+      };
+    }
+    // start Vitest UI maximized only on supported browsers
+    if (options.ui && (browser === "chrome" || browser === "edge")) {
+      const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
+      const args = capabilities[key]?.args || [];
+      if (!args.includes("--start-maximized") && !args.includes("--start-fullscreen")) {
+        args.push("--start-maximized");
+      }
+      capabilities[key] ??= {};
+      capabilities[key].args = args;
+    }
+    const inspector = this.project.vitest.config.inspector;
+    if (inspector.enabled && (browser === "chrome" || browser === "edge")) {
+      const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
+      const args = capabilities[key]?.args || [];
+      // NodeJS equivalent defaults: https://nodejs.org/en/learn/getting-started/debugging#enable-inspector
+      const port = inspector.port || 9229;
+      const host = inspector.host || "127.0.0.1";
+      args.push(`--remote-debugging-port=${port}`);
+      args.push(`--remote-debugging-address=${host}`);
+      this.project.vitest.logger.log(`Debugger listening on ws://${host}:${port}`);
+      capabilities[key] ??= {};
+      capabilities[key].args = args;
+    }
+    return capabilities;
+  }
+  async openPage(sessionId, url) {
+    await this._throwIfClosing("creating the browser");
+    debug?.("[%s][%s] creating the browser page for %s", sessionId, this.browserName, url);
+    const browserInstance = await this.openBrowser();
+    debug?.("[%s][%s] browser page is created, opening %s", sessionId, this.browserName, url);
+    await browserInstance.url(url);
+    this.topLevelContext = await browserInstance.getWindowHandle();
+    await this._throwIfClosing("opening the url");
+  }
+  async _throwIfClosing(action) {
+    if (this.closing) {
+      debug?.(`[%s] provider was closed, cannot perform the action${action ? ` ${action}` : ""}`, this.browserName);
+      await (this.browser?.sessionId ? this.browser?.deleteSession?.() : null);
+      throw new Error(`[vitest] The provider was closed.`);
+    }
+  }
+  async close() {
+    debug?.("[%s] closing provider", this.browserName);
+    this.closing = true;
+    const browser = this.browser;
+    const sessionId = browser?.sessionId;
+    if (!browser || !sessionId) {
+      return;
+    }
+    // https://github.com/webdriverio/webdriverio/blob/ab1a2e82b13a9c7d0e275ae87e7357e1b047d8d3/packages/wdio-runner/src/index.ts#L486
+    await browser.deleteSession();
+    browser.sessionId = undefined;
+    this.browser = null;
+  }
+  async getCDPSession(_sessionId) {
+    return {
+      send: (method, params) => {
+        if (!this.browser) {
+          throw new Error(`The environment was torn down.`);
+        }
+        return this.browser.sendCommandAndGetResult(method, params ?? {}).catch((error) => {
+          return Promise.reject(new Error(`Failed to execute "${method}" command.`, { cause: error }));
+        });
+      },
+      on: () => {
+        throw new Error(`webdriverio provider doesn't support cdp.on()`);
+      },
+      once: () => {
+        throw new Error(`webdriverio provider doesn't support cdp.once()`);
+      },
+      off: () => {
+        throw new Error(`webdriverio provider doesn't support cdp.off()`);
+      }
+    };
+  }
+}
+
+export { WebdriverBrowserProvider, webdriverio };