Continues e2e test improvements

Author: eamodio

.gitignore

@@ -4,6 +4,7 @@
 **/.vscode-clean/**
 **/.vscode-test/**
 **/.vscode-test-web/**
+**/test-results/**
 dist
 out
 node_modules

package.json

@@ -26757,6 +26757,7 @@
 		"reset": "pnpm run clean && pnpm install --force",
 		"test": "vscode-test",
 		"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",
 		"watch": "webpack --watch --mode development",
 		"watch:extension": "webpack --watch --mode development --config-name extension",
 		"watch:quick": "webpack --watch --mode development --env quick",

tests/e2e/baseTest.ts

@@ -0,0 +1,126 @@
+/* eslint-disable no-empty-pattern */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { ElectronApplication, Page } from '@playwright/test';
+import { _electron, test as base } from '@playwright/test';
+import { downloadAndUnzipVSCode } from '@vscode/test-electron/out/download';
+import { GitFixture } from './fixtures/git';
+import { GitLensPage } from './pageObjects/gitLensPage';
+
+export { expect } from '@playwright/test';
+export { GitFixture } from './fixtures/git';
+
+export const MaxTimeout = 10000;
+
+export interface LaunchOptions {
+	vscodeVersion?: string;
+	/**
+	 * Optional async setup callback that runs before VS Code launches.
+	 * Use this to create a test repo, files, or any other setup needed.
+	 * Returns the path to open in VS Code.
+	 * If not provided, opens the extension folder.
+	 */
+	setup?: () => Promise<string>;
+}
+
+export interface VSCodeInstance {
+	page: Page;
+	electronApp: ElectronApplication;
+	gitlens: GitLensPage;
+}
+
+/** Base fixtures for all E2E tests */
+interface BaseFixtures {
+	createTempFolder: () => Promise<string>;
+	/**
+	 * Creates and initializes a new Git repository in a temporary directory.
+	 * The repository is automatically cleaned up after the test.
+	 * Returns a GitFixture instance for interacting with the repository.
+	 */
+	createGitRepo: () => Promise<GitFixture>;
+}
+
+interface WorkerFixtures {
+	vscode: VSCodeInstance;
+	vscodeOptions: LaunchOptions;
+}
+
+export const test = base.extend<BaseFixtures, WorkerFixtures>({
+	// Default options (can be overridden per-file)
+	// eslint-disable-next-line no-restricted-globals
+	vscodeOptions: [{ vscodeVersion: process.env.VSCODE_VERSION ?? 'stable' }, { scope: 'worker', option: true }],
+
+	// vscode launches VS Code with GitLens extension (shared per worker)
+	vscode: [
+		async ({ vscodeOptions }, use) => {
+			const tempDir = await createTmpDir();
+			const vscodePath = await downloadAndUnzipVSCode(vscodeOptions.vscodeVersion ?? 'stable');
+			const extensionPath = path.join(__dirname, '..', '..');
+
+			// Run setup callback if provided, otherwise open extension folder
+			const workspacePath = vscodeOptions.setup ? await vscodeOptions.setup() : extensionPath;
+
+			const electronApp = await _electron.launch({
+				executablePath: vscodePath,
+				args: [
+					'--no-sandbox',
+					'--disable-gpu-sandbox',
+					'--disable-updates',
+					'--skip-welcome',
+					'--skip-release-notes',
+					'--disable-workspace-trust',
+					`--extensionDevelopmentPath=${extensionPath}`,
+					`--extensions-dir=${path.join(tempDir, 'extensions')}`,
+					`--user-data-dir=${path.join(tempDir, 'user-data')}`,
+					workspacePath,
+				],
+			});
+
+			const page = await electronApp.firstWindow();
+			const gitlens = new GitLensPage(page);
+
+			// Wait for GitLens to activate before providing to tests
+			await gitlens.waitForActivation();
+
+			await use({ page: page, electronApp: electronApp, gitlens: gitlens } satisfies VSCodeInstance);
+
+			// Cleanup
+			await electronApp.close();
+			await fs.promises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+		},
+		{ scope: 'worker' },
+	],
+
+	createGitRepo: async ({}, use) => {
+		const repos: GitFixture[] = [];
+		await use(async () => {
+			const dir = await createTmpDir();
+			const git = new GitFixture(dir);
+			await git.init();
+			repos.push(git);
+			return git;
+		});
+		// Cleanup after test
+		for (const repo of repos) {
+			await fs.promises.rm(repo.repoDir, { recursive: true, force: true }).catch(() => {});
+		}
+	},
+
+	createTempFolder: async ({}, use) => {
+		const dirs: string[] = [];
+		await use(async () => {
+			const dir = await createTmpDir();
+			dirs.push(dir);
+			return dir;
+		});
+		// Cleanup after test
+		for (const dir of dirs) {
+			await fs.promises.rm(dir, { recursive: true, force: true }).catch(() => {});
+		}
+	},
+});
+
+export async function createTmpDir(): Promise<string> {
+	return fs.promises.realpath(await fs.promises.mkdtemp(path.join(os.tmpdir(), 'gltest-')));
+}

tests/e2e/fixtures/git.ts

@@ -0,0 +1,138 @@
+/* eslint-disable no-restricted-globals */
+import { spawn } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export class GitFixture {
+	constructor(private readonly repoPath: string) {}
+
+	get repoDir(): string {
+		return this.repoPath;
+	}
+
+	async init(): Promise<void> {
+		await fs.mkdir(this.repoPath, { recursive: true });
+		await this.git('init');
+		// Configure user for commits
+		await this.git('config', 'user.email', '[email protected]');
+		await this.git('config', 'user.name', 'Your Name');
+		// Initial commit to have a HEAD
+		await this.commit('Initial commit');
+	}
+
+	async commit(message: string, fileName: string = 'test-file.txt', content: string = 'content'): Promise<void> {
+		const filePath = path.join(this.repoPath, fileName);
+		await fs.writeFile(filePath, content);
+		await this.git('add', fileName);
+		await this.git('commit', '-m', message);
+	}
+
+	async branch(name: string): Promise<void> {
+		await this.git('branch', name);
+	}
+
+	async checkout(name: string, create: boolean = false): Promise<void> {
+		if (create) {
+			await this.git('checkout', '-b', name);
+		} else {
+			await this.git('checkout', name);
+		}
+	}
+
+	async worktree(worktreePath: string, branch: string): Promise<void> {
+		await this.git('worktree', 'add', worktreePath, branch);
+	}
+
+	/**
+	 * Start an interactive rebase. This will open the rebase editor.
+	 * @param onto The commit or ref to rebase onto (e.g., 'HEAD~3')
+	 * @param env Additional environment variables
+	 */
+	async rebaseInteractive(onto: string, env?: Record<string, string>): Promise<void> {
+		await this.git('rebase', '-i', onto, env);
+	}
+
+	/**
+	 * Abort an in-progress rebase
+	 */
+	async rebaseAbort(): Promise<void> {
+		await this.git('rebase', '--abort');
+	}
+
+	/**
+	 * Get the current branch name
+	 */
+	async getCurrentBranch(): Promise<string> {
+		return this.git('rev-parse', '--abbrev-ref', 'HEAD');
+	}
+
+	/**
+	 * Get the short SHA of a ref
+	 */
+	async getShortSha(ref: string = 'HEAD'): Promise<string> {
+		return this.git('rev-parse', '--short', ref);
+	}
+
+	/**
+	 * Check if a rebase is in progress
+	 */
+	async isRebaseInProgress(): Promise<boolean> {
+		try {
+			await this.git('rev-parse', '--verify', 'REBASE_HEAD');
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Reset the repository to a specific ref
+	 * @param ref The ref to reset to (default: HEAD)
+	 * @param mode The reset mode: 'soft', 'mixed', or 'hard' (default: 'hard')
+	 */
+	async reset(ref: string = 'HEAD', mode: 'soft' | 'mixed' | 'hard' = 'hard'): Promise<void> {
+		await this.git('reset', `--${mode}`, ref);
+	}
+
+	/**
+	 * Clean untracked files and directories
+	 */
+	async clean(): Promise<void> {
+		await this.git('clean', '-fd');
+	}
+
+	private async git(command: string, ...args: (string | Record<string, string> | undefined)[]): Promise<string> {
+		// Separate command args from env options
+		const cmdArgs: string[] = [];
+		let envOverrides: Record<string, string> | undefined;
+
+		for (const arg of args) {
+			if (typeof arg === 'string') {
+				cmdArgs.push(arg);
+			} else if (typeof arg === 'object' && arg !== null) {
+				envOverrides = arg;
+			}
+		}
+
+		const fullArgs = [command, ...cmdArgs];
+		return new Promise((resolve, reject) => {
+			const child = spawn('git', fullArgs, {
+				cwd: this.repoPath,
+				env: envOverrides ? { ...process.env, ...envOverrides } : process.env,
+			});
+			let stdout = '';
+			let stderr = '';
+
+			child.stdout.on('data', (data: string | Buffer) => (stdout += data.toString()));
+			child.stderr.on('data', (data: string | Buffer) => (stderr += data.toString()));
+
+			child.on('close', code => {
+				if (code === 0) {
+					resolve(stdout.trim());
+				} else {
+					reject(new Error(`Git command failed: git ${fullArgs.join(' ')}\n${stderr}`));
+				}
+			});
+		});
+	}
+}

tests/e2e/pageObjects/components/activityBar.ts

@@ -1,5 +1,6 @@
 import type { Locator, Page } from '@playwright/test';
-import { MaxTimeout } from '../../specs/baseTest';
+import { MaxTimeout } from '../../baseTest';
+import type { VSCodePage } from '../vscodePage';
 
 /**
  * Component for VS Code Activity Bar interactions.
@@ -8,7 +9,10 @@ import { MaxTimeout } from '../../specs/baseTest';
 export class ActivityBar {
 	private readonly container: Locator;
 
-	constructor(private readonly page: Page) {
+	constructor(
+		private readonly vscode: VSCodePage,
+		private readonly page: Page,
+	) {
 		this.container = page.locator('[id="workbench.parts.activitybar"]');
 	}