@vitest/browser 1.6.0 → 2.0.0-beta.10

package/dist/providers.js

@@ -1,111 +1,8 @@
-const playwrightBrowsers = ["firefox", "webkit", "chromium"];
-class PlaywrightBrowserProvider {
-  name = "playwright";
-  cachedBrowser = null;
-  cachedPage = null;
-  browser;
-  ctx;
-  options;
-  getSupportedBrowsers() {
-    return playwrightBrowsers;
-  }
-  initialize(project, { browser, options }) {
-    this.ctx = project;
-    this.browser = browser;
-    this.options = options;
-  }
-  async openBrowserPage() {
-    if (this.cachedPage)
-      return this.cachedPage;
-    const options = this.ctx.config.browser;
-    const playwright = await import('playwright');
-    const browser = await playwright[this.browser].launch({
-      ...this.options?.launch,
-      headless: options.headless
-    });
-    this.cachedBrowser = browser;
-    this.cachedPage = await browser.newPage(this.options?.page);
-    return this.cachedPage;
-  }
-  async openPage(url) {
-    const browserPage = await this.openBrowserPage();
-    await browserPage.goto(url);
-  }
-  async close() {
-    const page = this.cachedPage;
-    this.cachedPage = null;
-    const browser = this.cachedBrowser;
-    this.cachedBrowser = null;
-    await page?.close();
-    await browser?.close();
-  }
-}
-
-const webdriverBrowsers = ["firefox", "chrome", "edge", "safari"];
-class WebdriverBrowserProvider {
-  name = "webdriverio";
-  cachedBrowser = null;
-  browser;
-  ctx;
-  options;
-  getSupportedBrowsers() {
-    return webdriverBrowsers;
-  }
-  async initialize(ctx, { browser, options }) {
-    this.ctx = ctx;
-    this.browser = browser;
-    this.options = options;
-  }
-  async openBrowser() {
-    if (this.cachedBrowser)
-      return this.cachedBrowser;
-    const options = this.ctx.config.browser;
-    if (this.browser === "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');
-    this.cachedBrowser = await remote({
-      ...this.options,
-      logLevel: "error",
-      capabilities: this.buildCapabilities()
-    });
-    return this.cachedBrowser;
-  }
-  buildCapabilities() {
-    const capabilities = {
-      ...this.options?.capabilities,
-      browserName: this.browser
-    };
-    const headlessMap = {
-      chrome: ["goog:chromeOptions", ["headless", "disable-gpu"]],
-      firefox: ["moz:firefoxOptions", ["-headless"]],
-      edge: ["ms:edgeOptions", ["--headless"]]
-    };
-    const options = this.ctx.config.browser;
-    const browser = this.browser;
-    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 };
-    }
-    return capabilities;
-  }
-  async openPage(url) {
-    const browserInstance = await this.openBrowser();
-    await browserInstance.url(url);
-  }
-  async close() {
-    await Promise.all([
-      this.cachedBrowser?.sessionId ? this.cachedBrowser?.deleteSession?.() : null
-    ]);
-    process.exit();
-  }
-}
+import { W as WebdriverBrowserProvider, P as PlaywrightBrowserProvider } from './webdriver-CXn0ag9T.js';
 
-class NoneBrowserProvider {
-  name = "none";
+class PreviewBrowserProvider {
+  name = "preview";
+  supportsParallelism = false;
   ctx;
   open = false;
   getSupportedBrowsers() {
@@ -114,19 +11,22 @@ class NoneBrowserProvider {
   isOpen() {
     return this.open;
   }
+  getCommandsContext() {
+    return {};
+  }
   async initialize(ctx) {
     this.ctx = ctx;
     this.open = false;
     if (ctx.config.browser.headless)
-      throw new Error(`You've enabled headless mode for "none" provider but it doesn't support it.`);
+      throw new Error(`You've enabled headless mode for "preview" provider but it doesn't support it. Use "playwright" or "webdriverio" instead: https://vitest.dev/guide/browser#configuration`);
   }
-  async openPage(_url) {
+  async openPage(_contextId, url) {
     this.open = true;
     if (!this.ctx.browser)
       throw new Error("Browser is not initialized");
     const options = this.ctx.browser.config.server;
     const _open = options.open;
-    options.open = _url;
+    options.open = url;
     this.ctx.browser.openBrowser();
     options.open = _open;
   }
@@ -136,6 +36,6 @@ class NoneBrowserProvider {
 
 const webdriverio = WebdriverBrowserProvider;
 const playwright = PlaywrightBrowserProvider;
-const none = NoneBrowserProvider;
+const preview = PreviewBrowserProvider;
 
-export { none, playwright, webdriverio };
+export { playwright, preview, webdriverio };

package/dist/webdriver-CXn0ag9T.js

@@ -0,0 +1,170 @@
+const playwrightBrowsers = ["firefox", "webkit", "chromium"];
+class PlaywrightBrowserProvider {
+  name = "playwright";
+  supportsParallelism = true;
+  browser = null;
+  browserName;
+  ctx;
+  options;
+  contexts = /* @__PURE__ */ new Map();
+  pages = /* @__PURE__ */ new Map();
+  browserPromise = null;
+  getSupportedBrowsers() {
+    return playwrightBrowsers;
+  }
+  initialize(project, { browser, options }) {
+    this.ctx = project;
+    this.browserName = browser;
+    this.options = options;
+  }
+  async openBrowser() {
+    if (this.browserPromise)
+      return this.browserPromise;
+    if (this.browser)
+      return this.browser;
+    this.browserPromise = (async () => {
+      const options = this.ctx.config.browser;
+      const playwright = await import('playwright');
+      const browser = await playwright[this.browserName].launch({
+        ...this.options?.launch,
+        headless: options.headless
+      });
+      this.browser = browser;
+      this.browserPromise = null;
+      return this.browser;
+    })();
+    return this.browserPromise;
+  }
+  async createContext(contextId) {
+    if (this.contexts.has(contextId))
+      return this.contexts.get(contextId);
+    const browser = await this.openBrowser();
+    const context = await browser.newContext({
+      ...this.options?.context,
+      ignoreHTTPSErrors: true,
+      serviceWorkers: "allow"
+    });
+    this.contexts.set(contextId, context);
+    return context;
+  }
+  getPage(contextId) {
+    const page = this.pages.get(contextId);
+    if (!page)
+      throw new Error(`Page "${contextId}" not found`);
+    return page;
+  }
+  getCommandsContext(contextId) {
+    const page = this.getPage(contextId);
+    const tester = page.frameLocator("iframe[data-vitest]");
+    return {
+      page,
+      tester,
+      get body() {
+        return page.frameLocator("iframe[data-vitest]").locator("body");
+      }
+    };
+  }
+  async openBrowserPage(contextId) {
+    if (this.pages.has(contextId)) {
+      const page2 = this.pages.get(contextId);
+      await page2.close();
+      this.pages.delete(contextId);
+    }
+    const context = await this.createContext(contextId);
+    const page = await context.newPage();
+    this.pages.set(contextId, page);
+    return page;
+  }
+  async openPage(contextId, url) {
+    const browserPage = await this.openBrowserPage(contextId);
+    await browserPage.goto(url);
+  }
+  async close() {
+    const browser = this.browser;
+    this.browser = null;
+    await Promise.all([...this.pages.values()].map((p) => p.close()));
+    this.pages.clear();
+    await Promise.all([...this.contexts.values()].map((c) => c.close()));
+    this.contexts.clear();
+    await browser?.close();
+  }
+}
+
+const webdriverBrowsers = ["firefox", "chrome", "edge", "safari"];
+class WebdriverBrowserProvider {
+  name = "webdriverio";
+  supportsParallelism = false;
+  browser = null;
+  browserName;
+  ctx;
+  options;
+  getSupportedBrowsers() {
+    return webdriverBrowsers;
+  }
+  async initialize(ctx, { browser, options }) {
+    this.ctx = ctx;
+    this.browserName = browser;
+    this.options = options;
+  }
+  async beforeCommand() {
+    const page = this.browser;
+    const iframe = await page.findElement("css selector", "iframe[data-vitest]");
+    await page.switchToFrame(iframe);
+  }
+  async afterCommand() {
+    await this.browser.switchToParentFrame();
+  }
+  getCommandsContext() {
+    return {
+      browser: this.browser
+    };
+  }
+  async openBrowser() {
+    if (this.browser)
+      return this.browser;
+    const options = this.ctx.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');
+    this.browser = await remote({
+      ...this.options,
+      logLevel: "error",
+      capabilities: this.buildCapabilities()
+    });
+    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.ctx.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 };
+    }
+    return capabilities;
+  }
+  async openPage(_contextId, url) {
+    const browserInstance = await this.openBrowser();
+    await browserInstance.url(url);
+  }
+  async close() {
+    await Promise.all([
+      this.browser?.sessionId ? this.browser?.deleteSession?.() : null
+    ]);
+    process.exit();
+  }
+}
+
+export { PlaywrightBrowserProvider as P, WebdriverBrowserProvider as W };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser",
   "type": "module",
-  "version": "1.6.0",
+  "version": "2.0.0-beta.10",
   "description": "Browser running for Vitest",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -24,6 +24,10 @@
       "types": "./providers.d.ts",
       "default": "./dist/providers.js"
     },
+    "./context": {
+      "types": "./context.d.ts",
+      "default": "./context.js"
+    },
     "./providers/webdriverio": {
       "types": "./providers/webdriverio.d.ts"
     },
@@ -43,7 +47,7 @@
   "peerDependencies": {
     "playwright": "*",
     "webdriverio": "*",
-    "vitest": "1.6.0"
+    "vitest": "2.0.0-beta.10"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -57,22 +61,28 @@
     }
   },
   "dependencies": {
-    "magic-string": "^0.30.5",
+    "@testing-library/dom": "^10.1.0",
+    "@testing-library/user-event": "^14.5.2",
+    "magic-string": "^0.30.10",
+    "msw": "^2.3.1",
     "sirv": "^2.0.4",
-    "@vitest/utils": "1.6.0"
+    "@vitest/utils": "2.0.0-beta.10"
   },
   "devDependencies": {
-    "@types/ws": "^8.5.9",
-    "@wdio/protocols": "^8.29.7",
+    "@types/ws": "^8.5.10",
+    "@wdio/protocols": "^8.38.0",
+    "birpc": "0.2.17",
+    "flatted": "^3.3.1",
+    "pathe": "^1.1.2",
     "periscopic": "^4.0.2",
-    "playwright": "^1.41.0",
-    "playwright-core": "^1.41.0",
+    "playwright": "^1.44.1",
+    "playwright-core": "^1.44.1",
     "safaridriver": "^0.1.2",
-    "webdriverio": "^8.32.2",
-    "@vitest/runner": "1.6.0",
-    "@vitest/ui": "1.6.0",
-    "@vitest/ws-client": "1.6.0",
-    "vitest": "1.6.0"
+    "webdriverio": "^8.38.2",
+    "@vitest/runner": "2.0.0-beta.10",
+    "@vitest/ui": "2.0.0-beta.10",
+    "@vitest/ws-client": "2.0.0-beta.10",
+    "vitest": "2.0.0-beta.10"
   },
   "scripts": {
     "build": "rimraf dist && pnpm build:node && pnpm build:client",

package/providers/playwright.d.ts

@@ -1,8 +1,20 @@
-import type { Browser, LaunchOptions } from 'playwright'
+import type {
+  BrowserContextOptions,
+  FrameLocator,
+  LaunchOptions,
+  Locator,
+  Page,
+} from 'playwright'
 
 declare module 'vitest/node' {
   interface BrowserProviderOptions {
     launch?: LaunchOptions
-    page?: Parameters<Browser['newPage']>[0]
+    context?: Omit<BrowserContextOptions, 'ignoreHTTPSErrors' | 'serviceWorkers'>
+  }
+
+  export interface BrowserCommandContext {
+    page: Page
+    tester: FrameLocator
+    body: Locator
   }
 }

package/providers/webdriverio.d.ts

@@ -2,4 +2,8 @@ import type { RemoteOptions } from 'webdriverio'
 
 declare module 'vitest/node' {
   interface BrowserProviderOptions extends RemoteOptions {}
+
+  export interface BrowserCommandContext {
+    browser: WebdriverIO.Browser
+  }
 }

package/providers.d.ts

@@ -1,7 +1,7 @@
-import type { BrowserProvider } from 'vitest/node'
+import type { BrowserProviderModule } from 'vitest/node'
 
-declare const webdriverio: BrowserProvider
-declare const playwright: BrowserProvider
-declare const none: BrowserProvider
+declare const webdriverio: BrowserProviderModule
+declare const playwright: BrowserProviderModule
+declare const preview: BrowserProviderModule
 
-export { webdriverio, playwright, none }
+export { webdriverio, playwright, preview }