🆙 1.21.0 (#147348)

* 🆙 `playwright`

* fix install

* adopt latest apis

* comment

build/azure-pipelines/common/installPlaywright.js

@@ -5,7 +5,7 @@
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 const retry_1 = require("./retry");
-const { installDefaultBrowsersForNpmInstall } = require('playwright-core/lib/utils/registry');
+const { installDefaultBrowsersForNpmInstall } = require('playwright-core/lib/server');
 async function install() {
     await (0, retry_1.retry)(() => installDefaultBrowsersForNpmInstall());
 }

build/azure-pipelines/common/installPlaywright.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { retry } from './retry';
-const { installDefaultBrowsersForNpmInstall } = require('playwright-core/lib/utils/registry');
+const { installDefaultBrowsersForNpmInstall } = require('playwright-core/lib/server');
 
 async function install() {
 	await retry(() => installDefaultBrowsersForNpmInstall());

package.json

@@ -95,7 +95,7 @@
   },
   "devDependencies": {
     "7zip": "0.0.6",
-    "@playwright/test": "1.20.2",
+    "@playwright/test": "1.21.0",
     "@types/applicationinsights": "0.20.0",
     "@types/cookie": "^0.3.3",
     "@types/copy-webpack-plugin": "^6.0.3",

src/vs/platform/driver/browser/driver.ts

@@ -205,6 +205,10 @@ export class BrowserWindowDriver implements IWindowDriver {
 
 		throw new Error('Method not implemented.');
 	}
+
+	async exitApplication(): Promise<void> {
+		// No-op in web
+	}
 }
 
 export function registerWindowDriver(): void {

src/vs/platform/driver/common/driver.ts

@@ -42,7 +42,7 @@ export interface IDriver {
 	getWindowIds(): Promise<number[]>;
 	startTracing(windowId: number, name: string): Promise<void>;
 	stopTracing(windowId: number, name: string, persist: boolean): Promise<void>;
-	exitApplication(): Promise<number /* main PID */>;
+	exitApplication(): Promise<void>;
 	dispatchKeybinding(windowId: number, keybinding: string): Promise<void>;
 	click(windowId: number, selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Promise<void>;
 	setValue(windowId: number, selector: string, text: string): Promise<void>;
@@ -69,6 +69,7 @@ export interface IWindowDriver {
 	writeInTerminal(selector: string, text: string): Promise<void>;
 	getLocaleInfo(): Promise<ILocaleInfo>;
 	getLocalizedStrings(): Promise<ILocalizedStrings>;
+	exitApplication(): Promise<void>;
 }
 //*END
 

src/vs/platform/driver/common/driverIpc.ts

@@ -83,6 +83,10 @@ export class WindowDriverChannelClient implements IWindowDriver {
 	getLocalizedStrings(): Promise<ILocalizedStrings> {
 		return this.channel.call('getLocalizedStrings');
 	}
+
+	exitApplication(): Promise<void> {
+		return this.channel.call('exitApplication');
+	}
 }
 
 export class WindowDriverRegistryChannelClient implements IWindowDriverRegistry {

src/vs/platform/driver/electron-main/driver.ts

@@ -96,12 +96,10 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 		return image.toPNG().toString('base64');
 	}
 
-	async exitApplication(): Promise<number> {
+	async exitApplication(): Promise<void> {
 		this.logService.info(`[driver] exitApplication()`);
 
-		this.lifecycleMainService.quit();
-
-		return process.pid;
+		await this.lifecycleMainService.quit();
 	}
 
 	async dispatchKeybinding(windowId: number, keybinding: string): Promise<void> {

src/vs/platform/driver/electron-sandbox/driver.ts

@@ -12,7 +12,7 @@ import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 
 interface INativeWindowDriverHelper {
-	exitApplication(): Promise<number /* main process PID */>;
+	exitApplication(): Promise<void>;
 }
 
 class NativeWindowDriver extends BrowserWindowDriver {
@@ -21,7 +21,7 @@ class NativeWindowDriver extends BrowserWindowDriver {
 		super();
 	}
 
-	exitApplication(): Promise<number> {
+	override exitApplication(): Promise<void> {
 		return this.helper.exitApplication();
 	}
 }

src/vs/platform/driver/node/driver.ts

@@ -59,7 +59,7 @@ export class DriverChannelClient implements IDriver {
 		return this.channel.call('stopTracing', [windowId, name, persist]);
 	}
 
-	exitApplication(): Promise<number> {
+	exitApplication(): Promise<void> {
 		return this.channel.call('exitApplication');
 	}
 

src/vs/workbench/electron-sandbox/window.ts

@@ -649,10 +649,8 @@ export class NativeWindow extends Disposable {
 		if (this.environmentService.enableSmokeTestDriver) {
 			const that = this;
 			registerWindowDriver({
-				async exitApplication(): Promise<number> {
-					that.nativeHostService.quit();
-
-					return that.environmentService.mainPid;
+				async exitApplication(): Promise<void> {
+					return that.nativeHostService.quit();
 				}
 			});
 		}

test/automation/src/code.ts

@@ -13,6 +13,7 @@ import { launch as launchPlaywrightElectron } from './playwrightElectron';
 import { Logger, measureAndLog } from './logger';
 import { copyExtension } from './extensions';
 import * as treekill from 'tree-kill';
+import { teardown } from './processes';
 
 const rootPath = join(__dirname, '../../..');
 
@@ -39,8 +40,8 @@ interface ICodeInstance {
 
 const instances = new Set<ICodeInstance>();
 
-function registerInstance(process: cp.ChildProcess, logger: Logger, type: string, kill: () => Promise<void>) {
-	const instance = { kill };
+function registerInstance(process: cp.ChildProcess, logger: Logger, type: string) {
+	const instance = { kill: () => teardown(process, logger) };
 	instances.add(instance);
 
 	process.stdout?.on('data', data => logger.log(`[${type}] stdout: ${data}`));
@@ -53,7 +54,7 @@ function registerInstance(process: cp.ChildProcess, logger: Logger, type: string
 	});
 }
 
-async function teardown(signal?: number) {
+async function teardownAll(signal?: number) {
 	stopped = true;
 
 	for (const instance of instances) {
@@ -66,9 +67,9 @@ async function teardown(signal?: number) {
 }
 
 let stopped = false;
-process.on('exit', () => teardown());
-process.on('SIGINT', () => teardown(128 + 2)); 	 // https://nodejs.org/docs/v14.16.0/api/process.html#process_signal_events
-process.on('SIGTERM', () => teardown(128 + 15)); // same as above
+process.on('exit', () => teardownAll());
+process.on('SIGINT', () => teardownAll(128 + 2)); 	 // https://nodejs.org/docs/v14.16.0/api/process.html#process_signal_events
+process.on('SIGTERM', () => teardownAll(128 + 15)); // same as above
 
 export async function launch(options: LaunchOptions): Promise<Code> {
 	if (stopped) {
@@ -79,25 +80,26 @@ export async function launch(options: LaunchOptions): Promise<Code> {
 
 	// Browser smoke tests
 	if (options.web) {
-		const { serverProcess, client, driver, kill } = await measureAndLog(launchPlaywrightBrowser(options), 'launch playwright (browser)', options.logger);
-		registerInstance(serverProcess, options.logger, 'server', kill);
+		const { serverProcess, client, driver } = await measureAndLog(launchPlaywrightBrowser(options), 'launch playwright (browser)', options.logger);
+		registerInstance(serverProcess, options.logger, 'server');
 
-		return new Code(client, driver, options.logger);
+		return new Code(client, driver, options.logger, serverProcess);
 	}
 
 	// Electron smoke tests (playwright)
 	else if (!options.legacy) {
-		const { client, driver } = await measureAndLog(launchPlaywrightElectron(options), 'launch playwright (electron)', options.logger);
+		const { electronProcess, client, driver } = await measureAndLog(launchPlaywrightElectron(options), 'launch playwright (electron)', options.logger);
+		registerInstance(electronProcess, options.logger, 'electron');
 
-		return new Code(client, driver, options.logger);
+		return new Code(client, driver, options.logger, electronProcess);
 	}
 
 	// Electron smoke tests (legacy driver)
 	else {
-		const { electronProcess, client, driver, kill } = await measureAndLog(launchElectron(options), 'launch electron', options.logger);
-		registerInstance(electronProcess, options.logger, 'electron', kill);
+		const { electronProcess, client, driver } = await measureAndLog(launchElectron(options), 'launch electron', options.logger);
+		registerInstance(electronProcess, options.logger, 'electron');
 
-		return new Code(client, driver, options.logger);
+		return new Code(client, driver, options.logger, electronProcess);
 	}
 }
 
@@ -109,7 +111,8 @@ export class Code {
 	constructor(
 		private client: IDisposable,
 		driver: IDriver,
-		readonly logger: Logger
+		readonly logger: Logger,
+		private readonly mainProcess: cp.ChildProcess
 	) {
 		this.driver = new Proxy(driver, {
 			get(target, prop) {
@@ -150,13 +153,15 @@ export class Code {
 	}
 
 	async exit(): Promise<void> {
-
-		// Start the exit flow via driver
-		const pid = await measureAndLog(this.driver.exitApplication(), 'driver.exitApplication()', this.logger);
-
 		return measureAndLog(new Promise<void>((resolve, reject) => {
+			const pid = this.mainProcess.pid!;
+
 			let done = false;
 
+			// Start the exit flow via driver
+			this.driver.exitApplication();
+
+			// Await the exit of the application
 			(async () => {
 				let retries = 0;
 				while (!done) {

test/automation/src/electron.ts

@@ -10,10 +10,10 @@ import { connect as connectElectronDriver, IDisposable, IDriver } from './driver
 import { ChildProcess, spawn, SpawnOptions } from 'child_process';
 import * as mkdirp from 'mkdirp';
 import { promisify } from 'util';
-import * as kill from 'tree-kill';
+import { teardown } from './processes';
 import { copyExtension } from './extensions';
 import { URI } from 'vscode-uri';
-import { Logger, measureAndLog } from './logger';
+import { measureAndLog } from './logger';
 import type { LaunchOptions } from './code';
 
 const root = join(__dirname, '..', '..', '..');
@@ -99,7 +99,7 @@ export async function resolveElectronConfiguration(options: LaunchOptions): Prom
 /**
  * @deprecated should use the playwright based electron support instead
  */
-export async function launch(options: LaunchOptions): Promise<{ electronProcess: ChildProcess; client: IDisposable; driver: IDriver; kill: () => Promise<void> }> {
+export async function launch(options: LaunchOptions): Promise<{ electronProcess: ChildProcess; client: IDisposable; driver: IDriver }> {
 	const { codePath, logger, verbose } = options;
 	const { env, args, electronPath } = await resolveElectronConfiguration(options);
 
@@ -126,8 +126,7 @@ export async function launch(options: LaunchOptions): Promise<{ electronProcess:
 			return {
 				electronProcess,
 				client,
-				driver,
-				kill: () => teardown(electronProcess, options.logger)
+				driver
 			};
 		} catch (err) {
 
@@ -152,31 +151,6 @@ export async function launch(options: LaunchOptions): Promise<{ electronProcess:
 	}
 }
 
-async function teardown(electronProcess: ChildProcess, logger: Logger): Promise<void> {
-	const electronPid = electronProcess.pid;
-	if (typeof electronPid !== 'number') {
-		return;
-	}
-
-	let retries = 0;
-	while (retries < 3) {
-		retries++;
-
-		try {
-			return await promisify(kill)(electronPid);
-		} catch (error) {
-			try {
-				process.kill(electronPid, 0); // throws an exception if the process doesn't exist anymore
-				logger.log(`Error tearing down electron client (pid: ${electronPid}, attempt: ${retries}): ${error}`);
-			} catch (error) {
-				return; // Expected when process is gone
-			}
-		}
-	}
-
-	logger.log(`Gave up tearing down electron client after ${retries} attempts...`);
-}
-
 export function getDevElectronPath(): string {
 	const buildPath = join(root, '.build');
 	const product = require(join(root, 'product.json'));

test/automation/src/playwrightBrowser.ts

@@ -10,7 +10,6 @@ import { mkdir } from 'fs';
 import { promisify } from 'util';
 import { IDriver, IDisposable } from './driver';
 import { URI } from 'vscode-uri';
-import * as kill from 'tree-kill';
 import { Logger, measureAndLog } from './logger';
 import type { LaunchOptions } from './code';
 import { PlaywrightDriver } from './playwrightDriver';
@@ -19,7 +18,7 @@ const root = join(__dirname, '..', '..', '..');
 
 let port = 9000;
 
-export async function launch(options: LaunchOptions): Promise<{ serverProcess: ChildProcess; client: IDisposable; driver: IDriver; kill: () => Promise<void> }> {
+export async function launch(options: LaunchOptions): Promise<{ serverProcess: ChildProcess; client: IDisposable; driver: IDriver }> {
 
 	// Launch server
 	const { serverProcess, endpoint } = await launchServer(options);
@@ -32,8 +31,7 @@ export async function launch(options: LaunchOptions): Promise<{ serverProcess: C
 		client: {
 			dispose: () => { /* there is no client to dispose for browser, teardown is triggered via exitApplication call */ }
 		},
-		driver: new PlaywrightDriver(browser, context, page, serverProcess.pid, options),
-		kill: () => teardown(serverProcess.pid, options.logger)
+		driver: new PlaywrightDriver(browser, context, page, serverProcess, options)
 	};
 }
 
@@ -145,30 +143,6 @@ async function launchBrowser(options: LaunchOptions, endpoint: string) {
 	return { browser, context, page };
 }
 
-export async function teardown(serverPid: number | undefined, logger: Logger): Promise<void> {
-	if (typeof serverPid !== 'number') {
-		return;
-	}
-
-	let retries = 0;
-	while (retries < 3) {
-		retries++;
-
-		try {
-			return await promisify(kill)(serverPid);
-		} catch (error) {
-			try {
-				process.kill(serverPid, 0); // throws an exception if the process doesn't exist anymore
-				logger.log(`Error tearing down server (pid: ${serverPid}, attempt: ${retries}): ${error}`);
-			} catch (error) {
-				return; // Expected when process is gone
-			}
-		}
-	}
-
-	logger.log(`Gave up tearing down server after ${retries} attempts...`);
-}
-
 function waitForEndpoint(server: ChildProcess, logger: Logger): Promise<string> {
 	return new Promise<string>((resolve, reject) => {
 		let endpointFound = false;

test/automation/src/playwrightDriver.ts

@@ -9,7 +9,8 @@ import { IDriver, IWindowDriver } from './driver';
 import { PageFunction } from 'playwright-core/types/structs';
 import { measureAndLog } from './logger';
 import { LaunchOptions } from './code';
-import { teardown } from './playwrightBrowser';
+import { teardown } from './processes';
+import { ChildProcess } from 'child_process';
 
 export class PlaywrightDriver implements IDriver {
 
@@ -36,7 +37,7 @@ export class PlaywrightDriver implements IDriver {
 		private readonly application: playwright.Browser | playwright.ElectronApplication,
 		private readonly context: playwright.BrowserContext,
 		private readonly page: playwright.Page,
-		private readonly serverPid: number | undefined,
+		private readonly serverProcess: ChildProcess | undefined,
 		private readonly options: LaunchOptions
 	) {
 	}
@@ -107,32 +108,28 @@ export class PlaywrightDriver implements IDriver {
 			// Ignore
 		}
 
-		// VSCode shutdown (desktop only)
-		let mainPid: number | undefined = undefined;
-		if (!this.options.web) {
+		// Web: exit via `close` method
+		if (this.options.web) {
 			try {
-				mainPid = await measureAndLog(this._evaluateWithDriver(([driver]) => (driver as unknown as IDriver).exitApplication()), 'driver.exitApplication()', this.options.logger);
+				await measureAndLog(this.application.close(), 'playwright.close()', this.options.logger);
+			} catch (error) {
+				this.options.logger.log(`Error closing appliction (${error})`);
+			}
+		}
+
+		// Desktop: exit via `driver.exitApplication`
+		else {
+			try {
+				await measureAndLog(this._evaluateWithDriver(([driver]) => driver.exitApplication()), 'driver.exitApplication()', this.options.logger);
 			} catch (error) {
 				this.options.logger.log(`Error exiting appliction (${error})`);
 			}
 		}
 
-		// Playwright shutdown
-		try {
-			await Promise.race([
-				measureAndLog(this.application.close(), 'playwright.close()', this.options.logger),
-				new Promise<void>(resolve => setTimeout(() => resolve(), 10000)) // TODO@bpasero mitigate https://github.com/microsoft/vscode/issues/146803
-			]);
-		} catch (error) {
-			this.options.logger.log(`Error closing appliction (${error})`);
+		// Server: via `teardown`
+		if (this.serverProcess) {
+			await measureAndLog(teardown(this.serverProcess, this.options.logger), 'teardown server process', this.options.logger);
 		}
-
-		// Server shutdown
-		if (typeof this.serverPid === 'number') {
-			await measureAndLog(teardown(this.serverPid, this.options.logger), 'teardown server', this.options.logger);
-		}
-
-		return mainPid ?? this.serverPid! /* when running web we must have a server Pid */;
 	}
 
 	async dispatchKeybinding(windowId: number, keybinding: string) {

test/automation/src/playwrightElectron.ts

@@ -9,8 +9,9 @@ import type { LaunchOptions } from './code';
 import { PlaywrightDriver } from './playwrightDriver';
 import { IElectronConfiguration, resolveElectronConfiguration } from './electron';
 import { measureAndLog } from './logger';
+import { ChildProcess } from 'child_process';
 
-export async function launch(options: LaunchOptions): Promise<{ client: IDisposable; driver: IDriver }> {
+export async function launch(options: LaunchOptions): Promise<{ electronProcess: ChildProcess; client: IDisposable; driver: IDriver }> {
 
 	// Resolve electron config and update
 	const { electronPath, args, env } = await resolveElectronConfiguration(options);
@@ -18,12 +19,14 @@ export async function launch(options: LaunchOptions): Promise<{ client: IDisposa
 
 	// Launch electron via playwright
 	const { electron, context, page } = await launchElectron({ electronPath, args, env }, options);
+	const electronProcess = electron.process();
 
 	return {
+		electronProcess,
 		client: {
 			dispose: () => { /* there is no client to dispose for electron, teardown is triggered via exitApplication call */ }
 		},
-		driver: new PlaywrightDriver(electron, context, page, undefined /* no server */, options)
+		driver: new PlaywrightDriver(electron, context, page, undefined /* no server process */, options)
 	};
 }
 

test/automation/src/processes.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ChildProcess } from 'child_process';
+import { promisify } from 'util';
+import * as treekill from 'tree-kill';
+import { Logger } from './logger';
+
+export async function teardown(p: ChildProcess, logger: Logger, retryCount = 3): Promise<void> {
+	const pid = p.pid;
+	if (typeof pid !== 'number') {
+		return;
+	}
+
+	let retries = 0;
+	while (retries < retryCount) {
+		retries++;
+
+		try {
+			return await promisify(treekill)(pid);
+		} catch (error) {
+			try {
+				process.kill(pid, 0); // throws an exception if the process doesn't exist anymore
+				logger.log(`Error tearing down process (pid: ${pid}, attempt: ${retries}): ${error}`);
+			} catch (error) {
+				return; // Expected when process is gone
+			}
+		}
+	}
+
+	logger.log(`Gave up tearing down process client after ${retries} attempts...`);
+}

yarn.lock

@@ -1046,10 +1046,10 @@
     node-addon-api "^3.2.1"
     node-gyp-build "^4.3.0"
 
-"@playwright/test@1.20.2":
-  version "1.20.2"
-  resolved "https://registry.yarnpkg.com/@playwright/test/-/test-1.20.2.tgz#0da1f24bf12d5a7249fa771a5344b76170f62653"
-  integrity sha512-unkLa+xe/lP7MVC0qpgadc9iSG1+LEyGBzlXhGS/vLGAJaSFs8DNfI89hNd5shHjWfNzb34JgPVnkRKCSNo5iw==
+"@playwright/test@1.21.0":
+  version "1.21.0"
+  resolved "https://registry.yarnpkg.com/@playwright/test/-/test-1.21.0.tgz#611dd3f469c539e5be3a764395effa40735742a6"
+  integrity sha512-jvgN3ZeAG6rw85z4u9Rc4uyj6qIaYlq2xrOtS7J2+CDYhzKOttab9ix9ELcvBOCHuQ6wgTfxfJYdh6DRZmQ9hg==
   dependencies:
     "@babel/code-frame" "7.16.7"
     "@babel/core" "7.16.12"
@@ -1080,7 +1080,7 @@
     ms "2.1.3"
     open "8.4.0"
     pirates "4.0.4"
-    playwright-core "1.20.2"
+    playwright-core "1.21.0"
     rimraf "3.0.2"
     source-map-support "0.4.18"
     stack-utils "2.0.5"
@@ -9002,10 +9002,10 @@ pkg-dir@^4.1.0, pkg-dir@^4.2.0:
   dependencies:
     find-up "^4.0.0"
 
-playwright-core@1.20.2:
-  version "1.20.2"
-  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.20.2.tgz#02336afd9a631d59a666f11f3492550201c6c31b"
-  integrity sha512-iV6+HftSPalynkq0CYJala1vaTOq7+gU9BRfKCdM9bAxNq/lFLrwbluug2Wt5OoUwbMABcnTThIEm3/qUhCdJQ==
+playwright-core@1.21.0:
+  version "1.21.0"
+  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.21.0.tgz#1b68e87f4fd2fc5653def1e61ccdef6845c604a6"
+  integrity sha512-yDGVs9qaaW6WiefgR7wH1CGt9D6D/X4U3jNpIzH0FjjrrWLCOYQo78Tu3SkW8X+/kWlBpj49iWf3QNSxhYc12Q==
   dependencies:
     colors "1.4.0"
     commander "8.3.0"