Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

17.0 KB
Raw Blame
import { expect, type Page, test } from "@playwright/test";
import { installDesktopBridge, installDesktopBridgeOverrides } from "./bridge";

// Front to back: Notes overlaps the left part of Safari.
const windows = [
	{
		id: "window:101:0",
		appName: "Notes",
		title: "Launch checklist",
		display_id: "1",
		x: 160,
		y: 140,
		width: 620,
		height: 460,
	},
	{
		id: "window:102:0",
		appName: "Safari",
		title: "Release notes",
		display_id: "1",
		x: 520,
		y: 220,
		width: 760,
		height: 560,
	},
];

async function openPicker(page: Page, allowArea = true, previousArea = false) {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(
		page,
		({ pickerWindows, allowArea, previousArea }) => {
			const api = (window as unknown as { electronAPI: Record<string, unknown> }).electronAPI;
			Object.assign(api, {
				getCapturePickerContext: async () => ({
					displayBounds: { x: 0, y: 0, width: 1440, height: 1000 },
					lastArea: previousArea ? { x: 100, y: 100, width: 400, height: 300 } : null,
					allowArea,
					windows: pickerWindows,
					cursor: null,
				}),
				completeCapturePick: async (pick: unknown) => {
					document.documentElement.dataset.pick = JSON.stringify(pick);
				},
				capturePickerReady: () => {
					document.documentElement.dataset.pickerReady = "true";
				},
			});
		},
		{ pickerWindows: windows, allowArea, previousArea },
	);
	await page.goto("/?windowType=capture-picker&displayId=1");
	await expect(page.locator("html")).toHaveAttribute("data-picker-ready", "true");
}

async function pick(page: Page) {
	const value = await page.locator("html").getAttribute("data-pick");
	return value ? JSON.parse(value) : undefined;
}

test("hovering highlights the frontmost window and a click picks it", async ({ page }) => {
	await openPicker(page);
	await page.mouse.move(600, 300);
	await expect(page.getByText("Notes — Launch checklist · 620 × 460")).toBeVisible();
	await page.screenshot({ path: "test-results/capture-picker.png", animations: "disabled" });

	await page.mouse.click(600, 300);
	expect(await pick(page)).toEqual({
		kind: "window",
		windowId: "window:101:0",
		displayId: 1,
		record: false,
	});
});

test("a click on the desktop picks the whole screen", async ({ page }) => {
	await openPicker(page);
	await page.mouse.move(1380, 60);
	await expect(page.getByText("Entire screen · 1440 × 1000")).toBeVisible();

	await page.mouse.click(1380, 60);
	expect(await pick(page)).toEqual({ kind: "screen", displayId: 1, record: false });
});

test("a drag draws an area", async ({ page }) => {
	await openPicker(page);
	await page.mouse.move(300, 200);
	await page.mouse.down();
	await page.mouse.move(700, 450, { steps: 8 });
	await page.mouse.up();
	await expect(page.getByText("Area · 400 × 250")).toBeVisible();
	expect(await pick(page)).toBeUndefined();
	await page.keyboard.press("Enter");

	expect(await pick(page)).toMatchObject({
		kind: "area",
		width: 400,
		height: 250,
		displayId: 1,
		record: false,
	});
});

test("Escape cancels", async ({ page }) => {
	await openPicker(page);
	await page.keyboard.press("Escape");
	expect(await pick(page)).toBeNull();
});

test("selection has no recording toolbar", async ({ page }) => {
	await openPicker(page);
	await page.mouse.click(600, 300);
	await expect(page.getByRole("button", { name: "Record", exact: true })).toHaveCount(0);
	expect(await pick(page)).toMatchObject({ kind: "window", record: false });
});

test("platforms without area capture keep drag selection on an existing screen", async ({
	page,
}) => {
	await openPicker(page, false);
	await page.mouse.move(1300, 100);
	await page.mouse.down();
	await page.mouse.move(1380, 180, { steps: 8 });
	await page.mouse.up();
	expect(await pick(page)).toMatchObject({ kind: "screen", record: false });
});

for (const { selected, trigger } of [
	{ selected: false, trigger: "source" },
	{ selected: false, trigger: "record" },
	{ selected: true, trigger: "source" },
]) {
	test(`HUD ${selected ? "keeps the selected source" : "starts without a selected source"} and opens the picker only on ${trigger} click`, async ({
		page,
	}) => {
		await installDesktopBridge(page);
		await installDesktopBridgeOverrides(
			page,
			(selected) => {
				Object.assign(window.electronAPI, {
					getSelectedSource: async () =>
						selected ? { id: "screen:1:0", name: "Existing screen" } : null,
					pickCaptureTarget: async () => {
						const html = document.documentElement;
						html.dataset.pickerCalls = String(
							Number(html.dataset.pickerCalls ?? 0) + 1,
						);
						return {
							success: true,
							source: { id: "window:101:0", name: "Selected window" },
						};
					},
				});
			},
			selected,
		);
		await page.goto("/?windowType=hud-overlay");
		const control = page.getByRole("button", { name: "Choose recording source" });
		await expect(control).toBeEnabled();
		if (selected) {
			await expect(control).toContainText("Existing screen");
		} else {
			await expect(control).toHaveText("Pick screen");
		}
		await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");
		await (trigger === "source"
			? control
			: page.getByRole("button", { name: "Record", exact: true })
		).click();
		await expect(page.locator("html")).toHaveAttribute("data-picker-calls", "1");
		await expect(control).toContainText("Selected window");
		await expect(page.getByRole("button", { name: "Record", exact: true })).toBeVisible();
	});
}

test("a newer selected-source event wins over the startup response", async ({ page }) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		Object.assign(window.electronAPI, {
			getSelectedSource: async () => {
				await new Promise((resolve) => setTimeout(resolve, 100));
				document.documentElement.dataset.sourceResolved = "true";
				return null;
			},
			onSelectedSourceChanged: (listener: (source: { name: string }) => void) => {
				const timer = setTimeout(() => listener({ name: "Newer window" }), 10);
				return () => clearTimeout(timer);
			},
			pickCaptureTarget: async () => {
				document.documentElement.dataset.pickerCalls = "1";
				return { success: false, canceled: true };
			},
		});
	});
	await page.goto("/?windowType=hud-overlay");
	await expect(page.locator("html")).toHaveAttribute("data-source-resolved", "true");
	await expect(page.getByRole("button", { name: "Choose recording source" })).toContainText(
		"Newer window",
	);
	await expect(page.locator("html")).not.toHaveAttribute("data-picker-calls");
});

test("areas can be moved and resized before Enter confirms them", async ({ page }) => {
	await openPicker(page);
	await page.mouse.move(300, 200);
	await page.mouse.down();
	await page.mouse.move(700, 450, { steps: 8 });
	await page.mouse.up();
	await expect(page.getByText("Area · 400 × 250")).toBeVisible();
	await page.mouse.move(400, 300);
	await page.mouse.down();
	await page.mouse.move(450, 350, { steps: 5 });
	await page.mouse.up();
	expect(await pick(page)).toBeUndefined();
	const corner = page.locator('[data-area-handle="se"]');
	const bounds = await corner.boundingBox();
	if (!bounds) throw new Error("Missing area resize handle");
	await page.mouse.move(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
	await page.mouse.down();
	await page.mouse.move(850, 600, { steps: 5 });
	await page.mouse.up();
	await expect(page.getByText("Area · 500 × 350")).toBeVisible();
	await page.keyboard.press("Enter");
	expect(await pick(page)).toMatchObject({
		kind: "area",
		x: 350,
		y: 250,
		width: 500,
		height: 350,
		record: false,
	});
});

for (const resize of [false, true]) {
	test(`area ${resize ? "resize" : "movement"} tracks pointer updates before the next render`, async ({
		page,
	}) => {
		await openPicker(page);
		await page.mouse.move(300, 200);
		await page.mouse.down();
		await page.mouse.move(700, 450);
		await page.mouse.up();
		await expect(page.getByText("Area · 400 × 250")).toBeVisible();
		const start = resize ? { x: 700, y: 450 } : { x: 400, y: 300 };
		await page.mouse.move(start.x, start.y);
		await page.mouse.down();
		await page.locator("div.fixed.inset-0.select-none").evaluate((overlay, start) => {
			for (const delta of [50, 1]) {
				overlay.dispatchEvent(
					new PointerEvent("pointermove", {
						bubbles: true,
						pointerId: 1,
						pointerType: "mouse",
						buttons: 1,
						clientX: start.x + delta,
						clientY: start.y + delta,
					}),
				);
			}
		}, start);
		await page.mouse.up();
		await page.keyboard.press("Enter");
		expect(await pick(page)).toMatchObject({
			kind: "area",
			x: resize ? 300 : 301,
			y: resize ? 200 : 201,
			width: resize ? 401 : 400,
			height: resize ? 251 : 250,
			record: false,
		});
	});
}

test("HUD reports a failed pick and keeps cancellation silent", async ({ page }) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		let canceled = false;
		Object.assign(window.electronAPI, {
			getSelectedSource: async () => null,
			pickCaptureTarget: async () => {
				const result = {
					success: false,
					canceled,
					message: "That window or screen is no longer available.",
				};
				canceled = true;
				return result;
			},
		});
	});
	await page.goto("/?windowType=hud-overlay");
	const source = page.getByRole("button", { name: "Choose recording source" });
	await source.click();
	await expect(
		page.getByText("That window or screen is no longer available.", { exact: true }),
	).toBeVisible();
	await page.getByText("That window or screen is no longer available.", { exact: true }).hover();
	await page.locator('[data-slot="toast-close"]').click();
	await source.click();
	await expect(source).toBeEnabled();
	await expect(
		page.getByText("That window or screen is no longer available.", { exact: true }),
	).toHaveCount(0);
});

test("unselected source reads Pick screen once and Record stays disabled while picking", async ({
	page,
}) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		Object.assign(window.electronAPI, {
			getSelectedSource: async () => null,
			pickCaptureTarget: async () =>
				new Promise((resolve) => {
					(window as unknown as { finishPicker: () => void }).finishPicker = () =>
						resolve({ success: false, canceled: true });
					document.documentElement.dataset.pickerPending = "true";
				}),
		});
	});
	await page.goto("/?windowType=hud-overlay");
	const source = page.getByRole("button", { name: "Choose recording source" });
	await expect(source).toBeEnabled();
	await expect(source).toHaveText("Pick screen");
	await expect(page.locator("html")).not.toHaveAttribute("data-picker-pending");
	await source.click();
	await expect(page.locator("html")).toHaveAttribute("data-picker-pending", "true");
	await expect(page.getByRole("button", { name: "Record", exact: true })).toBeDisabled();
	await page.evaluate(() => (window as unknown as { finishPicker: () => void }).finishPicker());
	await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
	await expect(source).toHaveText("Pick screen");
});

test("changing source cancels countdown and discards native warm-up before opening the picker", async ({
	page,
}) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;
		const events: string[] = [];
		Object.assign(window.electronAPI, {
			startNativeScreenRecording: async () => ({ success: true }),
			pauseNativeScreenRecording: async () => ({ success: true }),
			resumeNativeScreenRecording: async () => {
				events.push("resume");
				return { success: true };
			},
			startCountdown: async () => {
				document.documentElement.dataset.countdownStarted = "true";
				return new Promise((resolve) => {
					finishCountdown = resolve;
				});
			},
			cancelCountdown: async () => {
				events.push("cancel-countdown");
				finishCountdown({ success: false, cancelled: true });
				return { success: true };
			},
			stopNativeScreenRecording: async () => {
				events.push("stop-native");
				return { success: true, path: "/recordings/pending.mp4" };
			},
			deleteRecordingFile: async () => {
				events.push("delete-file");
				return { success: true };
			},
			setRecordingState: async (active: boolean) => {
				if (active) events.push("recording");
			},
			pickCaptureTarget: async () => {
				events.push("pick");
				document.documentElement.dataset.events = JSON.stringify(events);
				return { success: false, canceled: true };
			},
		});
	});
	await page.goto("/?windowType=hud-overlay");
	await page.getByRole("button", { name: "Record", exact: true }).click();
	await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");
	const source = page.getByRole("button", { name: "Choose recording source" });
	await expect(source).toBeEnabled();
	await source.click();
	await expect(page.locator("html")).toHaveAttribute(
		"data-events",
		JSON.stringify(["cancel-countdown", "stop-native", "delete-file", "pick"]),
	);
	await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
});

test("recording and pause expose no interactive source picker", async ({ page }) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		window.electronAPI.onRecordingStateChanged = (callback) => {
			const listener = (event: Event) => callback((event as CustomEvent).detail);
			window.addEventListener("test-recording", listener);
			return () => window.removeEventListener("test-recording", listener);
		};
		window.electronAPI.pickCaptureTarget = async () => {
			document.documentElement.dataset.pickerOpened = "true";
			return { success: false, canceled: true };
		};
	});
	await page.goto("/?windowType=hud-overlay");
	await expect(page.getByRole("button", { name: "Choose recording source" })).toBeEnabled();
	for (const paused of [false, true]) {
		await page.evaluate(
			(paused) =>
				window.dispatchEvent(
					new CustomEvent("test-recording", { detail: { recording: true, paused } }),
				),
			paused,
		);
		await expect(
			page.getByRole("button", { name: "Choose recording source" }),
		).not.toBeVisible();
		await expect(page.locator("html")).not.toHaveAttribute("data-picker-opened");
	}
});

test("changing source also cancels countdown on the browser capture path", async ({ page }) => {
	await installDesktopBridge(page);
	await installDesktopBridgeOverrides(page, () => {
		let finishCountdown: (result: { success: boolean; cancelled: boolean }) => void;
		Object.assign(window.electronAPI, {
			getPlatform: async () => "linux",
			startCountdown: async () => {
				document.documentElement.dataset.countdownStarted = "true";
				return new Promise((resolve) => {
					finishCountdown = resolve;
				});
			},
			cancelCountdown: async () => {
				document.documentElement.dataset.countdownCancelled = "true";
				finishCountdown({ success: false, cancelled: true });
				return { success: true };
			},
			pickCaptureTarget: async () => {
				document.documentElement.dataset.pickedAfterCancel =
					document.documentElement.dataset.countdownCancelled;
				return { success: false, canceled: true };
			},
		});
	});
	await page.goto("/?windowType=hud-overlay");
	await page.getByRole("button", { name: "Record", exact: true }).click();
	await expect(page.locator("html")).toHaveAttribute("data-countdown-started", "true");
	await page.getByRole("button", { name: "Choose recording source" }).click();
	await expect(page.locator("html")).toHaveAttribute("data-picked-after-cancel", "true");
	await expect(page.getByRole("button", { name: "Record", exact: true })).toBeEnabled();
});

test("reopening an area starts with window picking instead of the old area editor", async ({
	page,
}) => {
	await openPicker(page, true, true);
	await expect(page.locator("[data-area-handle]")).toHaveCount(0);
	await page.mouse.move(600, 300);
	await expect(page.getByText("Notes — Launch checklist · 620 × 460")).toBeVisible();
	await page.mouse.click(600, 300);
	expect(await pick(page)).toMatchObject({ kind: "window", windowId: "window:101:0" });
});

for (const destination of ["window", "screen"] as const) {
	test(`a drawn area can return to ${destination} picking without closing the picker`, async ({
		page,
	}) => {
		await openPicker(page);
		await page.mouse.move(300, 200);
		await page.mouse.down();
		await page.mouse.move(700, 450, { steps: 5 });
		await page.mouse.up();
		await expect(page.getByText("Area · 400 × 250")).toBeVisible();
		const change = page.getByRole("button", { name: "Choose another source", exact: true });
		if (destination === "window") {
			await change.focus();
			await page.keyboard.press("Enter");
		} else {
			await change.click();
		}
		await expect(page.locator("[data-area-handle]")).toHaveCount(0);
		expect(await pick(page)).toBeUndefined();
		const point = destination === "window" ? { x: 600, y: 300 } : { x: 1380, y: 60 };
		await page.mouse.move(point.x, point.y);
		await expect(
			page.getByText(
				destination === "window"
					? "Notes — Launch checklist · 620 × 460"
					: "Entire screen · 1440 × 1000",
			),
		).toBeVisible();
		await page.mouse.click(point.x, point.y);
		expect(await pick(page)).toMatchObject({ kind: destination, displayId: 1, record: false });
	});
}