Upload folder using huggingface_hub

6.11.0/tootils/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@self/tootils",
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"description": "Internal test utilities",
 	"type": "module",
 	"main": "src/index.ts",
@@ -18,7 +18,8 @@
 		".": "./src/index.ts",
 		"./render": "./src/render.ts",
 		"./shared-prop-tests": "./src/shared-prop-tests.ts",
-		"./app-launcher": "./src/app-launcher.ts"
+		"./app-launcher": "./src/app-launcher.ts",
+		"./download-command": "./src/download-command.ts"
 	},
 	"scripts": {
 		"package": "svelte-package --input=. --tsconfig=../../tsconfig.json"

6.11.0/tootils/src/download-command.ts

@@ -0,0 +1,136 @@
+import type { BrowserCommand } from "vitest/node";
+import { resolve } from "path";
+import { readFile } from "fs/promises";
+
+/**
+ * Vitest browser command that captures a real file download triggered by
+ * clicking an element. Runs server-side with access to the Playwright page.
+ *
+ * Sets up page.waitForEvent("download") BEFORE clicking, so the download
+ * event is never missed.
+ */
+export const expect_download: BrowserCommand<
+	[selector: string, options?: { timeout?: number }],
+	{ suggested_filename: string; content: string | null }
+> = async (context, selector, options) => {
+	const timeout = options?.timeout ?? 5000;
+	const provider = context.provider as any;
+	const page = provider.getPage(context.sessionId);
+	// Tests run inside an iframe; use the iframe locator to click
+	// but listen for the download event on the parent page.
+	const iframe = (context as any).iframe;
+
+	const [download] = await Promise.all([
+		page.waitForEvent("download", { timeout }),
+		iframe.locator(selector).click()
+	]);
+
+	const suggested_filename = download.suggestedFilename();
+	const path = await download.path();
+
+	let content: string | null = null;
+	if (path) {
+		const fs = await import("fs/promises");
+		content = await fs.readFile(path, "utf-8");
+	}
+
+	return {
+		suggested_filename,
+		content
+	};
+};
+
+/**
+ * Vitest browser command that sets files on an <input type="file"> element.
+ * Resolves fixture URL paths (e.g. "/test/test_files/bus.png") to absolute
+ * disk paths and uses Playwright's setInputFiles().
+ */
+export const set_file_inputs: BrowserCommand<
+	[file_urls: string[], selector?: string]
+> = async (context, file_urls, selector) => {
+	const root = context.project.config.root;
+	const iframe = (context as any).iframe;
+
+	const paths = file_urls.map((url) => resolve(root, url.replace(/^\//, "")));
+
+	await iframe
+		.locator(selector ?? 'input[type="file"]')
+		.first()
+		.setInputFiles(paths);
+};
+
+interface Drop_file_spec {
+	data: string; // base64
+	name: string;
+	mime_type: string;
+}
+
+/**
+ * Vitest browser command that simulates dropping files onto an element.
+ * Reads files from disk, transfers them as base64 into the browser context,
+ * and dispatches dragenter, dragover, and drop events with a real DataTransfer.
+ */
+export const drop_files: BrowserCommand<
+	[file_urls: string[], selector: string]
+> = async (context, file_urls, selector) => {
+	const root = context.project.config.root;
+
+	const files: Drop_file_spec[] = await Promise.all(
+		file_urls.map(async (url) => {
+			const abs = resolve(root, url.replace(/^\//, ""));
+			const data = (await readFile(abs)).toString("base64");
+			const name = abs.split("/").pop()!;
+			const ext = name.split(".").pop()!.toLowerCase();
+			const mime_type = MIME_TYPES[ext] || "application/octet-stream";
+			return { data, name, mime_type };
+		})
+	);
+
+	const iframe = (context as any).iframe;
+	await iframe
+		.locator(selector)
+		.first()
+		.evaluate((target: Element, files: Drop_file_spec[]) => {
+			const dt = new DataTransfer();
+			for (const f of files) {
+				const bytes = Uint8Array.from(atob(f.data), (c) => c.charCodeAt(0));
+				dt.items.add(new File([bytes], f.name, { type: f.mime_type }));
+			}
+
+			target.dispatchEvent(
+				new DragEvent("dragenter", {
+					dataTransfer: dt,
+					bubbles: true
+				})
+			);
+			target.dispatchEvent(
+				new DragEvent("dragover", {
+					dataTransfer: dt,
+					bubbles: true
+				})
+			);
+			target.dispatchEvent(
+				new DragEvent("drop", { dataTransfer: dt, bubbles: true })
+			);
+		}, files);
+};
+
+const MIME_TYPES: Record<string, string> = {
+	txt: "text/plain",
+	csv: "text/csv",
+	json: "application/json",
+	pdf: "application/pdf",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	ogg: "video/ogg",
+	avi: "video/x-msvideo",
+	wav: "audio/wav",
+	mp3: "audio/mpeg",
+	flac: "audio/flac"
+};

6.11.0/tootils/src/download.ts

@@ -0,0 +1,92 @@
+import { commands } from "vitest/browser";
+import type { FileData } from "@gradio/client";
+
+export interface DownloadResult {
+	suggested_filename: string;
+	content: string | null;
+}
+
+/**
+ * Clicks an element and captures the resulting file download.
+ *
+ * Uses a real browser download via Playwright under the hood —
+ * the file is actually downloaded and its content is readable.
+ *
+ * @param selector - CSS selector for the element to click
+ * @param options - Optional timeout (default 5000ms)
+ * @returns The downloaded file's suggested filename and text content
+ *
+ * @example
+ * ```ts
+ * const { suggested_filename, content } = await download_file("a.download-link");
+ * expect(suggested_filename).toBe("data.csv");
+ * expect(content).toContain("col1,col2");
+ * ```
+ */
+export async function download_file(
+	selector: string,
+	options?: { timeout?: number }
+): Promise<DownloadResult> {
+	return (commands as any).expect_download(selector, options);
+}
+
+/**
+ * Sets files on an `<input type="file">` element using real file fixtures.
+ *
+ * Accepts one or more FileData fixtures (e.g. TEST_JPG, TEST_PNG) and
+ * sets them on the file input, triggering the browser's native change event.
+ *
+ * @param files - One or more FileData fixtures to upload
+ * @param selector - CSS selector for the file input (default: 'input[type="file"]')
+ *
+ * @example
+ * ```ts
+ * import { render, upload_file, TEST_JPG } from "@self/tootils/render";
+ *
+ * const { listen } = await render(ImageUpload, { interactive: true });
+ * const upload = listen("upload");
+ *
+ * await upload_file(TEST_JPG);
+ *
+ * expect(upload).toHaveBeenCalled();
+ * ```
+ */
+export async function upload_file(
+	files: FileData | FileData[],
+	selector?: string
+): Promise<void> {
+	const file_list = Array.isArray(files) ? files : [files];
+	const urls = file_list.map((f) => f.url ?? f.path);
+	return (commands as any).set_file_inputs(urls, selector);
+}
+
+/**
+ * Simulates dragging and dropping files onto an element.
+ *
+ * Reads the fixture files from disk, constructs a real DataTransfer
+ * with File objects, and dispatches dragenter, dragover, and drop events
+ * on the target element.
+ *
+ * @param files - One or more FileData fixtures to drop
+ * @param selector - CSS selector for the drop target element
+ *
+ * @example
+ * ```ts
+ * import { render, drop_file, TEST_JPG } from "@self/tootils/render";
+ *
+ * const { listen } = await render(ImageUpload, { interactive: true });
+ * const upload = listen("upload");
+ *
+ * await drop_file(TEST_JPG, "[aria-label='Click to upload or drop files']");
+ *
+ * await vi.waitFor(() => expect(upload).toHaveBeenCalled());
+ * ```
+ */
+export async function drop_file(
+	files: FileData | FileData[],
+	selector: string
+): Promise<void> {
+	const file_list = Array.isArray(files) ? files : [files];
+	const urls = file_list.map((f) => f.url ?? f.path);
+	return (commands as any).drop_files(urls, selector);
+}

6.11.0/tootils/src/fixtures.ts

@@ -0,0 +1,21 @@
+import { FileData } from "@gradio/client";
+
+const BASE = "/test/test_files";
+
+function fixture(filename: string, mime_type: string, size: number): FileData {
+	const url = `${BASE}/${filename}`;
+	return new FileData({
+		path: url,
+		url,
+		orig_name: filename,
+		size,
+		mime_type
+	});
+}
+
+export const TEST_TXT = fixture("alphabet.txt", "text/plain", 26);
+export const TEST_JPG = fixture("cheetah1.jpg", "image/jpeg", 20552);
+export const TEST_PNG = fixture("bus.png", "image/png", 1951);
+export const TEST_MP4 = fixture("video_sample.mp4", "video/mp4", 261179);
+export const TEST_WAV = fixture("audio_sample.wav", "audio/wav", 16136);
+export const TEST_PDF = fixture("sample_file.pdf", "application/pdf", 10558);

6.11.0/tootils/src/render.ts

@@ -58,19 +58,21 @@ export async function render<
 	props?: Omit<Props, "gradio" | "loading_status"> & {
 		loading_status?: LoadingStatus;
 	},
-	_container?: HTMLElement
+	options?: {
+		container?: HTMLElement;
+	}
 ): Promise<
 	RenderResult<T> & {
-		listen: (event_name: string) => Mock;
+		listen: (event_name: string, opts?: { retrospective?: boolean }) => Mock;
 		set_data: (data: Record<string, any>) => Promise<void>;
 		get_data: () => Promise<Record<string, any>>;
 	}
 > {
 	let container: HTMLElement;
-	if (!_container) {
+	if (!options?.container) {
 		container = document.body;
 	} else {
-		container = _container;
+		container = options.container;
 	}
 
 	const target = container.appendChild(document.createElement("div"));
@@ -94,6 +96,7 @@ export async function render<
 	};
 
 	const event_listeners = new Map<string, Set<(data: any) => void>>();
+	const event_buffer: Array<{ event: string; data: any }> = [];
 
 	function notify_listeners(event: string, data: any): void {
 		const listeners = event_listeners.get(event);
@@ -105,15 +108,28 @@ export async function render<
 	}
 
 	const dispatcher = (_id: number, event: string, data: any): void => {
+		event_buffer.push({ event, data });
 		notify_listeners(event, data);
 	};
 
-	function listen(event_name: string): Mock {
+	function listen(
+		event_name: string,
+		opts?: { retrospective?: boolean }
+	): Mock {
 		const fn = vi.fn();
 		if (!event_listeners.has(event_name)) {
 			event_listeners.set(event_name, new Set());
 		}
 		event_listeners.get(event_name)!.add(fn);
+
+		if (opts?.retrospective) {
+			for (const entry of event_buffer) {
+				if (entry.event === event_name) {
+					fn(entry.data);
+				}
+			}
+		}
+
 		return fn;
 	}
 
@@ -242,4 +258,24 @@ export type FireFunction = (
 	event: Event
 ) => Promise<boolean>;
 
+export { download_file, upload_file, drop_file } from "./download.js";
+
+/**
+ * Creates a mock client suitable for components that use file uploads.
+ * The upload mock echoes back the input FileData unchanged.
+ */
+export function mock_client(): Record<string, any> {
+	return {
+		upload: async (file_data: any[]) => file_data,
+		stream: async () => ({ onmessage: null, close: () => {} })
+	};
+}
+export {
+	TEST_TXT,
+	TEST_JPG,
+	TEST_PNG,
+	TEST_MP4,
+	TEST_WAV,
+	TEST_PDF
+} from "./fixtures.js";
 export * from "@testing-library/dom";