Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

test/browser-diagnostics.ts

Raw
import type { Page, Request, TestInfo } from "@playwright/test";

// Only allowlisted paths and numeric media state leave the browser fixture.
// Never export query strings, headers, bodies, DOM, console messages or images.
export function diagnosticPath(value: string): string {
	try {
		const url = new URL(value);
		if (!/^https?:$/.test(url.protocol) || url.hostname !== "127.0.0.1")
			return "[external]";
		if (url.pathname === "/") return "/";
		if (["/api/state", "/api/events"].includes(url.pathname))
			return url.pathname;
		if (/^\/browser\/[\w.-]+\.(?:js|css)$/.test(url.pathname))
			return url.pathname;
		if (url.pathname.startsWith("/.system/"))
			return `[fixture]${/\.(webm|mp4|html)$/.exec(url.pathname)?.[0] ?? ""}`;
		return "[local route]";
	} catch {
		return "[invalid URL]";
	}
}

type Event = {
	ms: number;
	kind: string;
	document: number;
	request?: number;
	path?: string;
	navigation?: boolean;
	status?: number;
	aborted?: boolean;
	range?: string;
};
export type BrowserDiagnostics = {
	snapshot(): Promise<{ events: Event[]; dropped: number; media: unknown }>;
};

export function observeBrowserDiagnostics(page: Page): BrowserDiagnostics {
	const started = Date.now();
	const events: Event[] = [];
	const requests = new WeakMap<Request, number>();
	let document = 0;
	let nextRequest = 0;
	let dropped = 0;
	const record = (kind: string, extra: Partial<Event> = {}) => {
		if (events.length === 64) {
			events.shift();
			dropped++;
		}
		events.push({ ms: Date.now() - started, kind, document, ...extra });
	};
	const id = (request: Request) => {
		let value = requests.get(request);
		if (value === undefined) {
			value = ++nextRequest;
			requests.set(request, value);
		}
		return value;
	};
	page.on("request", (request) =>
		record("request", {
			request: id(request),
			path: diagnosticPath(request.url()),
			navigation: request.isNavigationRequest(),
		}),
	);
	page.on("requestfailed", (request) =>
		record("requestfailed", {
			request: id(request),
			path: diagnosticPath(request.url()),
			aborted: request.failure()?.errorText === "net::ERR_ABORTED",
		}),
	);
	page.on("response", (response) => {
		if (
			response.request().resourceType() !== "media" &&
			response.status() < 400
		)
			return;
		const range = (response.headers()["content-range"] ?? "").slice(0, 96);
		record("response", {
			request: id(response.request()),
			path: diagnosticPath(response.url()),
			status: response.status(),
			...(/^bytes \d+-\d+\/(?:\d+|\*)$/.test(range) && { range }),
		});
	});
	page.on("framenavigated", (frame) => {
		if (frame === page.mainFrame()) {
			document++;
			record("navigation", { path: diagnosticPath(frame.url()) });
		}
	});
	page.on("domcontentloaded", () => record("domcontentloaded"));
	page.on("load", () => record("load"));
	page.on("close", () => record("close"));
	return {
		async snapshot() {
			let timer: ReturnType<typeof setTimeout> | undefined;
			try {
				const media = await Promise.race([
					page
						.evaluate(() =>
							Array.from(globalThis.document.querySelectorAll("video"))
								.slice(0, 2)
								.map((video) => ({
									readyState: video.readyState,
									networkState: video.networkState,
									paused: video.paused,
									ended: video.ended,
									errorCode: video.error?.code ?? null,
									currentTime: Number.isFinite(video.currentTime)
										? video.currentTime
										: null,
								})),
						)
						.catch(() => null),
					new Promise<null>((resolve) => {
						timer = setTimeout(() => resolve(null), 500);
					}),
				]);
				const safeMedia = Array.isArray(media)
					? media.slice(0, 2).flatMap((value) => {
							if (!value || typeof value !== "object") return [];
							const numeric = (key: keyof typeof value) =>
								typeof value[key] === "number" && Number.isFinite(value[key])
									? value[key]
									: null;
							return [
								{
									readyState: numeric("readyState"),
									networkState: numeric("networkState"),
									paused: value.paused === true,
									ended: value.ended === true,
									errorCode: numeric("errorCode"),
									currentTime: numeric("currentTime"),
								},
							];
						})
					: null;
				return { events: [...events], dropped, media: safeMedia };
			} finally {
				clearTimeout(timer);
			}
		},
	};
}

export async function emitBrowserFailureDiagnostics(
	suite: "canvas" | "the-system",
	info: TestInfo,
	pages: BrowserDiagnostics[],
): Promise<void> {
	const snapshots = await Promise.all(
		pages.slice(0, 4).map((page) => page.snapshot()),
	);
	const report = {
		schema: 1,
		suite,
		line: info.line,
		project: ["chromium", "firefox"].includes(info.project.name)
			? info.project.name
			: "other",
		pages: snapshots,
	};
	// Metadata only; bound output even if a fixture produces many resource events.
	while (
		Buffer.byteLength(JSON.stringify(report)) > 24_000 &&
		snapshots.some((page) => page.events.length)
	) {
		for (const page of snapshots)
			if (page.events.length) {
				page.events.shift();
				page.dropped++;
			}
	}
	console.error(`PI_EXT_BROWSER_DIAGNOSTICS=${JSON.stringify(report)}`);
}