Ensures e2e runner gets built in all cases

Switches to commands for reliability/speed

Author: eamodio

package.json

@@ -26770,8 +26770,8 @@
 		"rebuild": "pnpm run reset && pnpm run build",
 		"reset": "pnpm run clean && pnpm install --force",
 		"test": "vscode-test",
-		"test:e2e": "pnpm run build:e2e-runner && playwright test -c tests/e2e/playwright.config.ts",
-		"test:e2e:insiders": "pnpm run build:e2e-runner && set VSCODE_VERSION=insiders && playwright test -c tests/e2e/playwright.config.ts",
+		"test:e2e": "playwright test -c tests/e2e/playwright.config.ts",
+		"test:e2e:insiders": "set VSCODE_VERSION=insiders && playwright test -c tests/e2e/playwright.config.ts",
 		"build:e2e-runner": "esbuild tests/e2e/runner/src/index.ts --bundle --outfile=tests/e2e/runner/dist/index.js --platform=node --external:vscode --format=cjs",
 		"watch": "webpack --watch --mode development",
 		"watch:extension": "webpack --watch --mode development --config-name extension",

tests/e2e/baseTest.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-empty-pattern */
+import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -16,6 +17,15 @@ export type { VSCode } from './fixtures/vscodeEvaluator';
 
 export const MaxTimeout = 10000;
 
+/** Ensures the E2E runner is built before tests run */
+function ensureRunnerBuilt(): void {
+	const runnerDist = path.join(__dirname, 'runner', 'dist', 'index.js');
+	if (!fs.existsSync(runnerDist)) {
+		const rootDir = path.resolve(__dirname, '../..');
+		execSync('pnpm run build:e2e-runner', { cwd: rootDir, stdio: 'inherit' });
+	}
+}
+
 /** Default VS Code settings applied to all E2E tests */
 const defaultUserSettings: Record<string, unknown> = {
 	// Disable telemetry
@@ -52,23 +62,17 @@ export interface LaunchOptions {
 }
 
 export interface VSCodeInstance {
-	page: Page;
-	electronApp: ElectronApplication;
+	electron: {
+		app: ElectronApplication;
+		/** Path to the VS Code executable for this test instance */
+		executablePath: string;
+		/** Launch arguments used for this VS Code instance (for reuse in sequence editor, etc.) */
+		args: string[];
+		/** Path to the workspace opened in VS Code */
+		workspacePath: string;
+	};
 	gitlens: GitLensPage;
-	/**
-	 * Evaluate a function in the VS Code Extension Host context.
-	 * The function receives the `vscode` module as its first argument.
-	 *
-	 * @example
-	 * ```ts
-	 * await vscode.evaluate(vscode => {
-	 *   vscode.commands.executeCommand('gitlens.showCommitGraph');
-	 * });
-	 *
-	 * const version = await vscode.evaluate(vscode => vscode.version);
-	 * ```
-	 */
-	evaluate: VSCodeEvaluator['evaluate'];
+	page: Page;
 }
 
 /** Base fixtures for all E2E tests */
@@ -94,6 +98,9 @@ export const test = base.extend<BaseFixtures, WorkerFixtures>({
 	// vscode launches VS Code with GitLens extension (shared per worker)
 	vscode: [
 		async ({ vscodeOptions }, use) => {
+			// Ensure the E2E runner is built (handles VS Code extension skipping globalSetup)
+			ensureRunnerBuilt();
+
 			const tempDir = await createTmpDir();
 			const vscodePath = await downloadAndUnzipVSCode(vscodeOptions.vscodeVersion ?? 'stable');
 			const extensionPath = path.join(__dirname, '..', '..');
@@ -112,7 +119,7 @@ export const test = base.extend<BaseFixtures, WorkerFixtures>({
 			// Run setup callback if provided, otherwise open extension folder
 			const workspacePath = vscodeOptions.setup ? await vscodeOptions.setup() : extensionPath;
 
-			const electronApp = await _electron.launch({
+			const options: { executablePath: string; args: string[] } = {
 				executablePath: vscodePath,
 				args: [
 					'--no-sandbox',
@@ -127,7 +134,9 @@ export const test = base.extend<BaseFixtures, WorkerFixtures>({
 					`--user-data-dir=${userDataDir}`,
 					workspacePath,
 				],
-			});
+			} satisfies Parameters<typeof _electron.launch>[0];
+
+			const electronApp = await _electron.launch(options);
 
 			// Connect to the VS Code test server using Playwright's internal API
 			const evaluator = await VSCodeEvaluator.connect(electronApp);
@@ -140,10 +149,9 @@ export const test = base.extend<BaseFixtures, WorkerFixtures>({
 			await gitlens.waitForActivation();
 
 			await use({
-				page: page,
-				electronApp: electronApp,
+				electron: { app: electronApp, ...options, workspacePath: workspacePath },
 				gitlens: gitlens,
-				evaluate: evaluate,
+				page: page,
 			} satisfies VSCodeInstance);
 
 			// Cleanup

tests/e2e/fixtures/vscodeEvaluator.ts

@@ -11,7 +11,6 @@ import type { ChildProcess } from 'child_process';
 import type { EventEmitter } from 'events';
 import readline from 'readline';
 import type { ElectronApplication } from '@playwright/test';
-import { _electron } from '@playwright/test';
 
 // Re-export vscode types for use in evaluate callbacks
 export type VSCode = typeof import('vscode');
@@ -52,9 +51,9 @@ export class VSCodeEvaluator {
 	 */
 	static async connect(electronApp: ElectronApplication, timeout = 30000): Promise<VSCodeEvaluator> {
 		// Access Playwright's internal implementation to get the process
-		// The _electron._connection.toImpl() method converts public API objects to internal implementations
+		// The electronApp._connection.toImpl() method converts public API objects to internal implementations
 
-		const connection = (_electron as any)._connection;
+		const connection = (electronApp as any)._connection;
 		const electronAppImpl = connection.toImpl(electronApp) as ElectronAppImpl;
 		const process = electronAppImpl._process;
 

tests/e2e/pageObjects/components/panel.ts

@@ -24,19 +24,21 @@ export class Panel {
 	}
 
 	async close(): Promise<void> {
-		if (!(await this.isVisible())) return;
+		await this.vscode.executeCommand('workbench.action.closePanel', 'View: Hide Panel');
 
-		// await this.vscode.executeCommand('View: Hide Panel', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
+		// if (!(await this.isVisible())) return;
+
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
 	}
 
 	async open(): Promise<void> {
-		if (await this.isVisible()) return;
+		await this.vscode.executeCommand('workbench.action.focusPanel', 'View: Focus into Panel');
+
+		// if (await this.isVisible()) return;
 
-		// await this.vscode.executeCommand('View: Focus into Panel', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
 	}
 
 	/**

tests/e2e/pageObjects/components/secondarySidebar.ts

@@ -24,19 +24,21 @@ export class SecondarySidebar {
 	}
 
 	async close(): Promise<void> {
-		if (!(await this.isVisible())) return;
+		await this.vscode.executeCommand('workbench.action.closeAuxiliaryBar', 'View: Close Secondary Side Bar');
 
-		// await this.vscode.executeCommand('View: Close Secondary Side Bar', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
+		// if (!(await this.isVisible())) return;
+
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
 	}
 
 	async open(): Promise<void> {
-		if (await this.isVisible()) return;
+		await this.vscode.executeCommand('workbench.action.focusAuxiliaryBar', 'View: Focus into Secondary Side Bar');
+
+		// if (await this.isVisible()) return;
 
-		// await this.vscode.executeCommand('View: Focus into Secondary Side Bar', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
 	}
 
 	/**

tests/e2e/pageObjects/components/sidebar.ts

@@ -24,19 +24,21 @@ export class Sidebar {
 	}
 
 	async close(): Promise<void> {
-		if (!(await this.isVisible())) return;
+		await this.vscode.executeCommand('workbench.action.closeSidebar', 'View: Close Primary Side Bar');
 
-		// await this.vscode.executeCommand('View: Close Primary Side Bar', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
+		// if (!(await this.isVisible())) return;
+
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'hidden', timeout: MaxTimeout });
 	}
 
 	async open(): Promise<void> {
-		if (await this.isVisible()) return;
+		await this.vscode.executeCommand('workbench.action.focusSideBar', 'View: Focus into Primary Side Bar');
+
+		// if (await this.isVisible()) return;
 
-		// await this.vscode.executeCommand('View: Focus into Primary Side Bar', 1);
-		await this.toggle.click();
-		await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
+		// await this.toggle.click();
+		// await this.container.waitFor({ state: 'visible', timeout: MaxTimeout });
 	}
 
 	/**

tests/e2e/setup.ts

@@ -1,6 +1,12 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
 import { downloadAndUnzipVSCode } from '@vscode/test-electron';
 
 // eslint-disable-next-line import-x/no-default-export
 export default async (): Promise<void> => {
+	// Build the E2E runner (required for VS Code extension host)
+	const rootDir = path.resolve(__dirname, '../..');
+	execSync('pnpm run build:e2e-runner', { cwd: rootDir, stdio: 'inherit' });
+
 	await downloadAndUnzipVSCode('stable');
 };