@vitest/browser-playwright 5.0.3 → 5.0.5

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { CustomComparatorsRegistry } from '@vitest/browser';
 export { defineBrowserCommand } from '@vitest/browser';
 import { Page, Frame, FrameLocator, BrowserContext, CDPSession, Browser, LaunchOptions, ConnectOptions, BrowserContextOptions } from 'playwright';
 import { ScreenshotMatcherOptions, ScreenshotComparatorRegistry, Locator } from 'vitest/browser';
-import { BrowserProvider, BrowserModuleMocker, TestProject, CDPSession as CDPSession$1, BrowserProviderOption } from 'vitest/node';
+import { BrowserProvider, BrowserModuleMocker, TestProject, CDPSession as CDPSession$1, BrowserProviderCloseOptions, BrowserProviderOption } from 'vitest/node';
 
 declare const playwrightBrowsers: readonly ["firefox", "webkit", "chromium"];
 type PlaywrightBrowser = (typeof playwrightBrowsers)[number];
@@ -57,13 +57,17 @@ declare class PlaywrightBrowserProvider implements BrowserProvider {
 	mocker: BrowserModuleMocker;
 	browserName: PlaywrightBrowser;
 	private browserPromise;
+	private launchOptionsJson;
 	private closing;
+	private armedContexts;
 	tracingContexts: Set<string>;
 	pendingTraces: Map<string, string>;
 	initScripts: string[];
 	constructor(project: TestProject, options: PlaywrightProviderOptions);
 	private onSIGTERM;
 	private openBrowser;
+	private armInterception;
+	private probeInterception;
 	private createMocker;
 	private createContext;
 	private getContextOptions;
@@ -80,7 +84,8 @@ declare class PlaywrightBrowserProvider implements BrowserProvider {
 	}): Promise<void>;
 	private _throwIfClosing;
 	getCDPSession(sessionid: string): Promise<CDPSession$1>;
-	close(): Promise<void>;
+	close(options?: BrowserProviderCloseOptions): Promise<void>;
+	private closeContexts;
 }
 declare module "vitest/node" {
 	interface BrowserCommandContext {

package/dist/index.js

@@ -875,18 +875,11 @@ function prewarmBrowser(project, options) {
 	if (warmBrowsers.has(project.config)) {
 		return;
 	}
-	let pending = pendingWarmBrowsers.get(project.vitest);
-	if (!pending) {
-		const pendingBrowsers = new Set();
-		pending = pendingBrowsers;
-		pendingWarmBrowsers.set(project.vitest, pendingBrowsers);
-		// Browsers whose projects never initialize a provider (they have no test
-		// files to run) are cleaned up when Vitest closes.
-		project.vitest.onClose(() => closeWarmBrowsers(pendingBrowsers));
-	}
+	const pending = getPendingWarmBrowsers(project.vitest);
 	const launchOptions = resolveLaunchOptions(project.config.browser, project.vitest.config.inspector, options, browserName);
 	const entry = {
-		launchOptionsJson: JSON.stringify(launchOptions),
+		config: project.config,
+		launchOptionsJson: getWarmBrowserKey(browserName, launchOptions),
 		pending,
 		promise: (async () => {
 			debug?.("[%s] prewarming the browser", browserName);
@@ -905,6 +898,34 @@ function prewarmBrowser(project, options) {
 	pending.add(entry);
 	warmBrowsers.set(project.config, entry);
 }
+function getWarmBrowserKey(browserName, launchOptions) {
+	return JSON.stringify([browserName, launchOptions]);
+}
+function getPendingWarmBrowsers(vitest) {
+	let pending = pendingWarmBrowsers.get(vitest);
+	if (!pending) {
+		const pendingBrowsers = new Set();
+		pending = pendingBrowsers;
+		pendingWarmBrowsers.set(vitest, pendingBrowsers);
+		// Browsers whose projects never initialize a provider (they have no test
+		// files to run) are cleaned up when Vitest closes.
+		vitest.onClose(() => closeWarmBrowsers(pendingBrowsers));
+	}
+	return pending;
+}
+// the pool closes an idle instance to start another project; the browser
+// process stays warm so the next project adopts it instead of launching one
+function keepWarmBrowser(project, browser, launchOptionsJson) {
+	const pending = getPendingWarmBrowsers(project.vitest);
+	const entry = {
+		config: project.config,
+		launchOptionsJson,
+		pending,
+		promise: browser
+	};
+	pending.add(entry);
+	warmBrowsers.set(project.config, entry);
+}
 function takeWarmBrowser(config) {
 	const warm = warmBrowsers.get(config);
 	if (warm) {
@@ -913,6 +934,22 @@ function takeWarmBrowser(config) {
 	}
 	return warm;
 }
+// fewer browsers are prewarmed than there are projects and the pool starts
+// projects in test order, so a browser prepared for another project is
+// adopted when it is the same browser launched with the same options
+function takeAnyWarmBrowser(vitest, launchOptionsJson) {
+	const pending = pendingWarmBrowsers.get(vitest);
+	if (!pending) {
+		return;
+	}
+	for (const warm of pending) {
+		if (warm.launchOptionsJson === launchOptionsJson) {
+			pending.delete(warm);
+			warmBrowsers.delete(warm.config);
+			return warm;
+		}
+	}
+}
 async function closeWarmBrowsers(pending) {
 	const closing = Array.from(pending, (warm) => warm.promise.then((browser) => browser.close()).catch(() => {}));
 	pending.clear();
@@ -955,7 +992,10 @@ class PlaywrightBrowserProvider {
 	mocker;
 	browserName;
 	browserPromise = null;
+	// set for a locally launched browser, which can be kept warm for another project
+	launchOptionsJson = null;
 	closing = false;
+	armedContexts = new WeakMap();
 	tracingContexts = new Set();
 	pendingTraces = new Map();
 	initScripts = [resolve(distRoot, "locators.js")];
@@ -1037,26 +1077,66 @@ class PlaywrightBrowserProvider {
 				});
 				this.browser = this.persistentContext.browser();
 			} else {
-				const warm = takeWarmBrowser(this.project.config);
-				if (warm && warm.launchOptionsJson === JSON.stringify(launchOptions)) {
+				const launchOptionsJson = getWarmBrowserKey(this.browserName, launchOptions);
+				let warm = takeWarmBrowser(this.project.config);
+				if (warm && warm.launchOptionsJson !== launchOptionsJson) {
+					debug?.("[%s] discarding the prewarmed browser, launch options changed", this.browserName);
+					void warm.promise.then((browser) => browser.close()).catch(() => {});
+					warm = undefined;
+				}
+				warm ??= takeAnyWarmBrowser(this.project.vitest, launchOptionsJson);
+				if (warm) {
 					const browser = await warm.promise.catch(() => null);
 					if (browser?.isConnected()) {
 						debug?.("[%s] adopting the prewarmed browser", this.browserName);
 						this.browser = browser;
 						this.browserPromise = null;
+						this.launchOptionsJson = launchOptionsJson;
 						return this.browser;
 					}
-				} else if (warm) {
-					debug?.("[%s] discarding the prewarmed browser, launch options changed", this.browserName);
-					void warm.promise.then((browser) => browser.close()).catch(() => {});
 				}
 				this.browser = await playwright[this.browserName].launch(launchOptions);
+				this.launchOptionsJson = launchOptionsJson;
 			}
 			this.browserPromise = null;
 			return this.browser;
 		})();
 		return this.browserPromise;
 	}
+	armInterception(page) {
+		if (this.browserName !== "chromium") {
+			return Promise.resolve();
+		}
+		const context = page.context();
+		const armed = this.armedContexts.get(context) ?? this.probeInterception(page).catch((error) => {
+			this.armedContexts.delete(context);
+			throw error;
+		});
+		this.armedContexts.set(context, armed);
+		return armed;
+	}
+	async probeInterception(page) {
+		const probeUrl = "/__vitest_interception_probe__";
+		const probePattern = `**${probeUrl}`;
+		const context = page.context();
+		await context.route(probePattern, (route) => route.fulfill({
+			status: 204,
+			headers: { "x-vitest-probe": "1" }
+		}));
+		const deadline = Date.now() + 5e3;
+		while (Date.now() < deadline) {
+			const intercepted = await page.evaluate((url) => fetch(url, {
+				cache: "no-store",
+				signal: AbortSignal.timeout(1e3)
+			}).then((r) => r.headers.has("x-vitest-probe"), () => false), probeUrl).catch(() => false);
+			if (intercepted) {
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+		await context.unroute(probePattern);
+		throw new Error(`Cannot verify that ${this.browserName} request interception is active after 5s; module mocks would not apply reliably (#8339)`);
+	}
 	createMocker() {
 		const idPredicates = new Map();
 		const sessionIds = new Map();
@@ -1090,12 +1170,14 @@ class PlaywrightBrowserProvider {
 				predicate
 			};
 		}
+		// the tester unmocks by path, but the route is registered by the full url
 		function predicateKey(sessionId, url) {
-			return `${sessionId}:${url}`;
+			return `${sessionId}:${new URL(url, "http://localhost").href}`;
 		}
 		return {
 			register: async (sessionId, module) => {
 				const page = this.getPage(sessionId);
+				await this.armInterception(page);
 				const { url: moduleUrl, predicate } = createPredicate(module.url);
 				const key = predicateKey(sessionId, moduleUrl);
 				const existingPredicate = idPredicates.get(key);
@@ -1128,7 +1210,7 @@ class PlaywrightBrowserProvider {
 							request.searchParams.set("mock", module.type);
 							url = request.href.slice(request.origin.length);
 						}
-						const result = await this.project.browser.vite.transformRequest(url).catch(() => null);
+						const result = await this.project.browser.vite.transformRequest(decodeURI(url)).catch(() => null);
 						if (!result) {
 							return route.continue();
 						}
@@ -1290,10 +1372,6 @@ class PlaywrightBrowserProvider {
 		if (this.closing) {
 			debug?.("[%s] provider was closed, cannot perform the action on %s", this.browserName, String(disposable));
 			await disposable?.close();
-			this.pages.clear();
-			this.contexts.clear();
-			this.browser = null;
-			this.browserPromise = null;
 			throw new Error(`[vitest] The provider was closed.`);
 		}
 	}
@@ -1309,7 +1387,7 @@ class PlaywrightBrowserProvider {
 			detach: cdp.detach.bind(cdp)
 		};
 	}
-	async close() {
+	async close(options) {
 		process.off("SIGTERM", this.onSIGTERM);
 		debug?.("[%s] closing provider", this.browserName);
 		this.closing = true;
@@ -1324,6 +1402,24 @@ class PlaywrightBrowserProvider {
 		}
 		const browser = this.browser;
 		this.browser = null;
+		const closed = this.closeContexts();
+		if (options?.keepWarm && browser && this.launchOptionsJson && browser.isConnected()) {
+			// registered before the contexts are closed, so the project that takes
+			// over the pool slot finds the browser right away and waits for it
+			const kept = closed.then(() => browser, async (error) => {
+				await browser.close().catch(() => {});
+				throw error;
+			});
+			keepWarmBrowser(this.project, kept, this.launchOptionsJson);
+			await kept;
+			debug?.("[%s] provider is closed, the browser is kept warm", this.browserName);
+			return;
+		}
+		await closed;
+		await browser?.close();
+		debug?.("[%s] provider is closed", this.browserName);
+	}
+	async closeContexts() {
 		await Promise.all(Array.from(this.pages.values(), (p) => p.close()));
 		this.pages.clear();
 		if (this.persistentContext) {
@@ -1332,8 +1428,6 @@ class PlaywrightBrowserProvider {
 			await Promise.all(Array.from(this.contexts.values(), (c) => c.close()));
 		}
 		this.contexts.clear();
-		await browser?.close();
-		debug?.("[%s] provider is closed", this.browserName);
 	}
 }
 function getHeaders(config) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser-playwright",
   "type": "module",
-  "version": "5.0.3",
+  "version": "5.0.5",
   "description": "Browser running for Vitest using playwright",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -43,7 +43,7 @@
   ],
   "peerDependencies": {
     "playwright": "*",
-    "vitest": "5.0.3"
+    "vitest": "5.0.5"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -51,13 +51,15 @@
     }
   },
   "dependencies": {
-    "@vitest/browser": "5.0.3",
-    "@vitest/mocker": "5.0.3",
-    "tinyrainbow": "^3.1.1"
+    "@vitest/browser": "5.0.5",
+    "@vitest/mocker": "5.0.5",
+    "tinyrainbow": "^3.2.0"
   },
   "devDependencies": {
-    "playwright": "^1.62.1",
-    "vitest": "5.0.3"
+    "pathe": "^2.0.3",
+    "playwright": "^1.64.0",
+    "vite": "8.0.11",
+    "vitest": "5.0.5"
   },
   "scripts": {
     "build": "premove dist && pnpm rollup -c",