@gradio/client 2.0.4 → 2.2.0

package/src/test/data.test.ts

@@ -11,11 +11,64 @@ import { config_response, endpoint_info } from "./test_data";
 import { BlobRef, Command } from "../types";
 import { FileData } from "../upload";
 
-const IS_NODE = process.env.TEST_MODE === "node";
+const IS_NODE =
+	typeof process !== "undefined" && process.env.TEST_MODE === "node";
+
+class FakeBuffer {
+	static from(data: string) {
+		return new Blob([data]);
+	}
+
+	static isBuffer() {
+		return false;
+	}
+
+	static isEncoding() {
+		return false;
+	}
+
+	static byteLength() {
+		return 0;
+	}
+
+	static concat() {
+		return new Blob([]);
+	}
+
+	static compare() {
+		return 0;
+	}
+
+	static alloc() {
+		return new Blob([]);
+	}
+
+	static allocUnsafe() {
+		return new Blob([]);
+	}
+
+	static allocUnsafeSlow() {
+		return new Blob([]);
+	}
+
+	static poolSize = 0;
+
+	static of() {
+		return new Blob([]);
+	}
+
+	equals(other: Blob) {
+		return this.toString() === other.toString();
+	}
+}
+
+if (!IS_NODE) {
+	globalThis.Buffer = FakeBuffer as unknown as BufferConstructor;
+}
 
 describe("walk_and_store_blobs", () => {
-	it("should convert a Buffer to a Blob", async () => {
-		const buffer = Buffer.from("test data");
+	it.skipIf(!IS_NODE)("should convert a Buffer to a Blob", async () => {
+		const buffer = globalThis.Buffer.from("test data");
 		const parts = await walk_and_store_blobs(buffer, "text");
 
 		expect(parts).toHaveLength(1);
@@ -74,75 +127,87 @@ describe("walk_and_store_blobs", () => {
 		expect(parts[0].blob).toBeInstanceOf(Blob);
 	});
 
-	it("should handle deep structures with arrays (with equality check)", async () => {
-		const image = new Blob([]);
-
-		const obj = {
-			a: [
-				{
-					b: [
-						{
-							data: [[image], image, [image, [image]]]
-						}
-					]
+	it.skipIf(!IS_NODE)(
+		"should handle deep structures with arrays (with equality check)",
+		async () => {
+			const image = new Blob([]);
+
+			const obj = {
+				a: [
+					{
+						b: [
+							{
+								data: [[image], image, [image, [image]]]
+							}
+						]
+					}
+				]
+			};
+			const parts = await walk_and_store_blobs(obj);
+
+			async function map_path(obj: Record<string, any>, parts: BlobRef[]) {
+				const { path, blob } = parts[parts.length - 1];
+				let ref = obj;
+				path.forEach((p) => (ref = ref[p]));
+
+				// since ref is a Blob and blob is a Blob, we deep equal check the two buffers instead
+				if (ref instanceof Blob && blob instanceof Blob) {
+					const refBuffer = Buffer.from(await ref.arrayBuffer());
+					const blobBuffer = Buffer.from(await blob.arrayBuffer());
+					return refBuffer.equals(blobBuffer);
 				}
-			]
-		};
-		const parts = await walk_and_store_blobs(obj);
-
-		async function map_path(obj: Record<string, any>, parts: BlobRef[]) {
-			const { path, blob } = parts[parts.length - 1];
-			let ref = obj;
-			path.forEach((p) => (ref = ref[p]));
-
-			// since ref is a Blob and blob is a Blob, we deep equal check the two buffers instead
-			if (ref instanceof Blob && blob instanceof Blob) {
-				const refBuffer = Buffer.from(await ref.arrayBuffer());
-				const blobBuffer = Buffer.from(await blob.arrayBuffer());
-				return refBuffer.equals(blobBuffer);
+
+				return ref === blob;
 			}
 
-			return ref === blob;
+			expect(parts[0].blob).toBeInstanceOf(Blob);
+			expect(map_path(obj, parts)).toBeTruthy();
 		}
+	);
 
-		expect(parts[0].blob).toBeInstanceOf(Blob);
-		expect(map_path(obj, parts)).toBeTruthy();
-	});
-
-	it("should handle buffer instances and return a BlobRef", async () => {
-		const buffer = Buffer.from("test");
-		const parts = await walk_and_store_blobs(buffer, undefined, ["blob"]);
-
-		expect(parts).toHaveLength(1);
-		expect(parts[0].blob).toBeInstanceOf(Blob);
-		expect(parts[0].path).toEqual(["blob"]);
-	});
+	it.skipIf(!IS_NODE)(
+		"should handle buffer instances and return a BlobRef",
+		async () => {
+			const buffer = Buffer.from("test");
+			const parts = await walk_and_store_blobs(buffer, undefined, ["blob"]);
 
-	it("should handle buffer instances with a path and return a BlobRef with the path", async () => {
-		const buffer = Buffer.from("test data");
-		const parts = await walk_and_store_blobs(buffer);
+			expect(parts).toHaveLength(1);
+			expect(parts[0].blob).toBeInstanceOf(Blob);
+			expect(parts[0].path).toEqual(["blob"]);
+		}
+	);
 
-		expect(parts).toHaveLength(1);
-		expect(parts[0].path).toEqual([]);
-		expect(parts[0].blob).toBeInstanceOf(Blob);
-	});
+	it.skipIf(!IS_NODE)(
+		"should handle buffer instances with a path and return a BlobRef with the path",
+		async () => {
+			const buffer = Buffer.from("test data");
+			const parts = await walk_and_store_blobs(buffer);
 
-	it("should convert an object with deep structures to BlobRefs", async () => {
-		const param = {
-			a: {
-				b: {
-					data: {
-						image: Buffer.from("test image")
+			expect(parts).toHaveLength(1);
+			expect(parts[0].path).toEqual([]);
+			expect(parts[0].blob).toBeInstanceOf(Blob);
+		}
+	);
+
+	it.skipIf(!IS_NODE)(
+		"should convert an object with deep structures to BlobRefs",
+		async () => {
+			const param = {
+				a: {
+					b: {
+						data: {
+							image: Buffer.from("test image")
+						}
 					}
 				}
-			}
-		};
-		const parts = await walk_and_store_blobs(param);
+			};
+			const parts = await walk_and_store_blobs(param);
 
-		expect(parts).toHaveLength(1);
-		expect(parts[0].path).toEqual(["a", "b", "data", "image"]);
-		expect(parts[0].blob).toBeInstanceOf(Blob);
-	});
+			expect(parts).toHaveLength(1);
+			expect(parts[0].path).toEqual(["a", "b", "data", "image"]);
+			expect(parts[0].blob).toBeInstanceOf(Blob);
+		}
+	);
 });
 describe("update_object", () => {
 	it("should update the value of a nested property", () => {
@@ -227,46 +292,50 @@ describe("post_message", () => {
 		vi.restoreAllMocks();
 	});
 
-	it("should send a message to the parent window and resolve with received data", async () => {
-		const test_data = { key: "value" };
-		const test_origin = "https://huggingface.co";
-
-		const post_message_mock = vi.fn();
+	it.skipIf(IS_NODE)(
+		"should send a message to the parent window and resolve with received data",
+		async () => {
+			const test_data = { key: "value" };
+			const test_origin = "https://huggingface.co";
+
+			// Create a mock for window.parent.postMessage that we'll spy on
+			const post_message_spy = vi
+				.spyOn(window.parent, "postMessage")
+				.mockImplementation(() => {});
+
+			// Mock MessageChannel
+			const original_message_channel = globalThis.MessageChannel;
+			const mock_port1 = {
+				onmessage: null as unknown as (event: { data: any }) => void,
+				close: vi.fn()
+			};
+			const mock_port2 = {};
 
-		global.window = {
-			// @ts-ignore
-			parent: {
-				postMessage: post_message_mock
+			class MockMessageChannel {
+				port1 = mock_port1;
+				port2 = mock_port2;
 			}
-		};
 
-		const message_channel_mock = {
-			port1: {
-				onmessage: (handler) => {
-					onmessage = handler;
-				},
-				close: vi.fn()
-			},
-			port2: {}
-		};
+			// Replace MessageChannel with our mock version
+			globalThis.MessageChannel = MockMessageChannel as any;
 
-		vi.stubGlobal("MessageChannel", function () {
-			this.port1 = message_channel_mock.port1;
-			this.port2 = message_channel_mock.port2;
-			return this;
-		});
+			const promise = post_message(test_data, test_origin);
 
-		const promise = post_message(test_data, test_origin);
+			// Simulate receiving a message back
+			if (mock_port1.onmessage) {
+				mock_port1.onmessage({ data: test_data } as any);
+			}
 
-		if (message_channel_mock.port1.onmessage) {
-			message_channel_mock.port1.onmessage({ data: test_data });
-		}
+			await expect(promise).resolves.toEqual(test_data);
+			expect(post_message_spy).toHaveBeenCalledWith(test_data, test_origin, [
+				mock_port2
+			]);
 
-		await expect(promise).resolves.toEqual(test_data);
-		expect(post_message_mock).toHaveBeenCalledWith(test_data, test_origin, [
-			message_channel_mock.port2
-		]);
-	});
+			// Restore original MessageChannel
+			globalThis.MessageChannel = original_message_channel;
+			post_message_spy.mockRestore();
+		}
+	);
 });
 
 describe("handle_file", () => {
@@ -277,31 +346,38 @@ describe("handle_file", () => {
 		expect(result).toBe(blob);
 	});
 
-	it("should handle a Buffer object and return it as a blob", () => {
-		const buffer = Buffer.from("test data");
-		const result = handle_file(buffer) as FileData;
-		expect(result).toBeInstanceOf(Blob);
-	});
-	it("should handle a local file path and return a Command object", () => {
-		const file_path = "./owl.png";
-		const result = handle_file(file_path) as Command;
-		expect(result).toBeInstanceOf(Command);
-		expect(result).toEqual({
-			type: "command",
-			command: "upload_file",
-			meta: { path: "./owl.png", name: "./owl.png", orig_path: "./owl.png" },
-			fileData: undefined
-		});
-	});
-
-	it("should handle a File object and return it as FileData", () => {
-		if (IS_NODE) {
-			return;
+	it.skipIf(!IS_NODE)(
+		"should handle a Buffer object and return it as a blob",
+		() => {
+			const buffer = Buffer.from("test data");
+			const result = handle_file(buffer) as FileData;
+			expect(result).toBeInstanceOf(Blob);
 		}
-		const file = new File(["test image"], "test.png", { type: "image/png" });
-		const result = handle_file(file) as FileData;
-		expect(result).toBeInstanceOf(Blob);
-	});
+	);
+
+	it.skipIf(!IS_NODE)(
+		"should handle a local file path and return a Command object",
+		() => {
+			const file_path = "./owl.png";
+			const result = handle_file(file_path) as Command;
+			expect(result).toBeInstanceOf(Command);
+			expect(result).toEqual({
+				type: "command",
+				command: "upload_file",
+				meta: { path: "./owl.png", name: "./owl.png", orig_path: "./owl.png" },
+				fileData: undefined
+			});
+		}
+	);
+
+	it.skipIf(IS_NODE)(
+		"should handle a File object and return it as FileData",
+		() => {
+			const file = new File(["test image"], "test.png", { type: "image/png" });
+			const result = handle_file(file) as FileData;
+			expect(result).toBeInstanceOf(Blob);
+		}
+	);
 
 	it("should throw an error for invalid input", () => {
 		const invalid_input = 123;

package/src/test/handlers.ts

@@ -630,9 +630,6 @@ export const handlers: RequestHandler[] = [
 					status: 200,
 					headers: {
 						"Content-Type": "application/json",
-						"Set-Cookie":
-							"access-token-123=abc; HttpOnly; Path=/; SameSite=none; Secure",
-						// @ts-ignore - multiple Set-Cookie headers are returned
 						"Set-Cookie":
 							"access-token-unsecure-123=abc; HttpOnly; Path=/; SameSite=none; Secure"
 					}
@@ -673,9 +670,6 @@ export const handlers: RequestHandler[] = [
 					status: 200,
 					headers: {
 						"Content-Type": "application/json",
-						"Set-Cookie":
-							"access-token-123=abc; HttpOnly; Path=/; SameSite=none; Secure",
-						// @ts-ignore - multiple Set-Cookie headers are returned
 						"Set-Cookie":
 							"access-token-unsecure-123=abc; HttpOnly; Path=/; SameSite=none; Secure"
 					}

package/src/test/init.test.ts

@@ -22,11 +22,14 @@ const broken_app_reference = "hmb/bye_world";
 const direct_app_reference = "https://hmb-hello-world.hf.space";
 const secret_direct_app_reference = "https://hmb-secret-world.hf.space";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("Client class", () => {
 	describe("initialisation", () => {

package/src/test/init_helpers.test.ts

@@ -9,11 +9,14 @@ import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
 import { Client } from "../client";
 import { INVALID_CREDENTIALS_MSG, MISSING_CREDENTIALS_MSG } from "../constants";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("resolve_root", () => {
 	it('should return the base URL if the root path starts with "http://"', () => {
@@ -102,7 +105,7 @@ describe("resolve_cookies", () => {
 
 	it("should connect to a private and authenticated space", async () => {
 		const client = await Client.connect("hmb/private_auth_space", {
-			hf_token: "hf_123",
+			token: "hf_123",
 			auth: ["admin", "pass1234"]
 		});
 

package/src/test/mock_eventsource.ts

@@ -1,6 +1,6 @@
 import { vi } from "vitest";
 
-if (process.env.TEST_MODE !== "node") {
+if (import.meta.env.TEST_MODE !== "node") {
 	Object.defineProperty(window, "EventSource", {
 		writable: true,
 		value: vi.fn().mockImplementation(() => ({

package/src/test/post_data.test.ts

@@ -2,12 +2,16 @@ import { Client } from "../client";
 
 import { initialise_server } from "./server";
 import { BROKEN_CONNECTION_MSG } from "../constants";
-const server = initialise_server();
 import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
 
-beforeAll(() => server.listen());
+let server: Awaited<ReturnType<typeof initialise_server>>;
+
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("post_data", () => {
 	it("should send a POST request with the correct headers and body", async () => {

package/src/test/server.ts

@@ -1,6 +1,31 @@
-import { setupServer } from "msw/node";
 import { handlers } from "./handlers";
+// import type { StartOptions } from 'msw';
+import type { SetupWorker, StartOptions } from "msw/browser";
 
-export function initialise_server(): any {
-	return setupServer(...handlers);
+const IS_NODE =
+	typeof process !== "undefined" && process.env.TEST_MODE === "node";
+
+interface MockServer {
+	start: (opts: StartOptions) => void | ReturnType<SetupWorker["start"]>;
+	stop: () => void | Promise<void>;
+	resetHandlers: (...handlers: any[]) => void;
+}
+
+export async function initialise_server(): Promise<MockServer> {
+	if (IS_NODE) {
+		const { setupServer } = await import("msw/node");
+		const server = setupServer(...handlers);
+		return {
+			start: (opts: StartOptions) => server.listen(opts),
+			stop: () => server.close(),
+			resetHandlers: (...h) => server.resetHandlers(...h)
+		};
+	}
+	const { setupWorker } = await import("msw/browser");
+	const worker = setupWorker(...handlers);
+	return {
+		start: (opts: StartOptions) => worker.start(opts),
+		stop: () => worker.stop(),
+		resetHandlers: (...h) => worker.resetHandlers(...h)
+	};
 }

package/src/test/spaces.test.ts

@@ -11,11 +11,14 @@ import { initialise_server } from "./server";
 import { hardware_sleeptime_response } from "./test_data";
 import { vi } from "vitest";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("set_space_timeout", () => {
 	it("should set the sleep timeout for a space", async () => {

package/src/test/stream.test.ts

@@ -14,11 +14,14 @@ import {
 	beforeEach
 } from "vitest";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("open_stream", () => {
 	let app: Client;
@@ -37,10 +40,10 @@ describe("open_stream", () => {
 		vi.clearAllMocks();
 	});
 
-	it("should throw an error if config is not defined", () => {
+	it("should throw an error if config is not defined", async () => {
 		app.config = undefined;
 
-		expect(async () => {
+		await expect(async () => {
 			await app.open_stream();
 		}).rejects.toThrow("Could not resolve app config");
 	});
@@ -60,22 +63,25 @@ describe("open_stream", () => {
 			throw new Error("stream instance is not defined");
 		}
 
-		const onMessageCallback = app.stream_instance.onmessage.bind(app);
-		const onErrorCallback = app.stream_instance.onerror.bind(app);
-
 		const message = { msg: "hello jerry" };
 
-		onMessageCallback({ data: JSON.stringify(message) });
+		app.stream_instance.onmessage({
+			data: JSON.stringify(message)
+		} as MessageEvent);
 		expect(app.stream_status.open).toBe(true);
 
 		expect(app.event_callbacks).toEqual({});
 		expect(app.pending_stream_messages).toEqual({});
 
 		const close_stream_message = { msg: "close_stream" };
-		onMessageCallback({ data: JSON.stringify(close_stream_message) });
+		app.stream_instance.onmessage({
+			data: JSON.stringify(close_stream_message)
+		} as MessageEvent);
 		expect(app.stream_status.open).toBe(false);
 
-		onErrorCallback({ data: JSON.stringify("404") });
+		app.stream_instance.onerror({
+			data: JSON.stringify("404")
+		} as MessageEvent);
 		expect(app.stream_status.open).toBe(false);
 	});
 });

package/src/test/upload_files.test.ts

@@ -3,18 +3,21 @@ import { describe, it, expect, afterEach, beforeAll, afterAll } from "vitest";
 import { Client } from "..";
 import { initialise_server } from "./server";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("upload_files", () => {
 	it("should upload files successfully", async () => {
 		const root_url = "https://hmb-hello-world.hf.space";
 
 		const client = await Client.connect("hmb/hello_world", {
-			hf_token: "hf_token"
+			token: "hf_token"
 		});
 
 		const files = [new Blob([], { type: "image/jpeg" })];

package/src/test/view_api.test.ts

@@ -8,11 +8,14 @@ const app_reference = "hmb/hello_world";
 const secret_app_reference = "hmb/secret_world";
 const secret_direct_app_reference = "https://hmb-secret-world.hf.space";
 
-const server = initialise_server();
+let server: Awaited<ReturnType<typeof initialise_server>>;
 
-beforeAll(() => server.listen());
+beforeAll(async () => {
+	server = await initialise_server();
+	await server.start({ quiet: true });
+});
 afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
+afterAll(() => server.stop());
 
 describe("view_api", () => {
 	test("viewing the api of a running, public app", async () => {

package/src/types.ts

@@ -402,6 +402,9 @@ export interface Status {
 	changed_state_ids?: number[];
 	time_limit?: number;
 	session_not_found?: boolean;
+	used_cache?: "full" | "partial" | null;
+	cache_duration?: number;
+	avg_time?: number;
 }
 
 export interface StatusMessage extends Status {