@gradio/client 0.17.0 → 0.18.0

package/src/test/data.test.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+	update_object,
+	walk_and_store_blobs,
+	skip_queue,
+	post_message
+} from "../helpers/data";
+import { NodeBlob } from "../client";
+import { config_response, endpoint_info } from "./test_data";
+import { BlobRef } from "../types";
+
+describe("walk_and_store_blobs", () => {
+	it("should convert a Buffer to a Blob", async () => {
+		const buffer = Buffer.from("test data");
+		const parts = await walk_and_store_blobs(buffer, "text");
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+	});
+
+	it("should return a Blob when passed a Blob", async () => {
+		const blob = new Blob(["test data"]);
+		const parts = await walk_and_store_blobs(
+			blob,
+			undefined,
+			[],
+			true,
+			endpoint_info
+		);
+
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+	});
+
+	it("should return blob: false when passed an image", async () => {
+		const blob = new Blob([]);
+		const parts = await walk_and_store_blobs(
+			blob,
+			"Image",
+			[],
+			true,
+			endpoint_info
+		);
+		expect(parts[0].blob).toBe(false);
+	});
+
+	it("should handle deep structures", async () => {
+		const image = new Blob([]);
+		const parts = await walk_and_store_blobs({ a: { b: { data: { image } } } });
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+		expect(parts[0].path).toEqual(["a", "b", "data", "image"]);
+	});
+
+	it("should handle deep structures with arrays", async () => {
+		const image = new Blob([]);
+		const parts = await walk_and_store_blobs({
+			a: [
+				{
+					b: [
+						{
+							data: [
+								{
+									image
+								}
+							]
+						}
+					]
+				}
+			]
+		});
+
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+	});
+
+	it("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 NodeBlob, we deep equal check the two buffers instead
+			if (ref instanceof Blob && blob instanceof NodeBlob) {
+				const refBuffer = Buffer.from(await ref.arrayBuffer());
+				const blobBuffer = Buffer.from(await blob.arrayBuffer());
+				return refBuffer.equals(blobBuffer);
+			}
+
+			return ref === blob;
+		}
+
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+		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(NodeBlob);
+		expect(parts[0].path).toEqual(["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].path).toEqual([]);
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+	});
+
+	it("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);
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].path).toEqual(["a", "b", "data", "image"]);
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+	});
+
+	it("should convert an object with primitive values to BlobRefs", async () => {
+		const param = {
+			test: "test"
+		};
+		const parts = await walk_and_store_blobs(param);
+
+		expect(parts).toHaveLength(1);
+		expect(parts[0].path).toEqual([]);
+		expect(parts[0].blob).toBeInstanceOf(NodeBlob);
+		expect(parts[0].type).toEqual("object");
+	});
+});
+describe("update_object", () => {
+	it("should update the value of a nested property", () => {
+		const obj = {
+			a: {
+				b: {
+					c: "old value"
+				}
+			}
+		};
+
+		const stack = ["a", "b", "c"];
+		const new_val = "new value";
+
+		update_object(obj, new_val, stack);
+
+		expect(obj.a.b.c).toBe(new_val);
+	});
+
+	it("should throw an error for invalid key type", () => {
+		const obj = {
+			a: {
+				b: {
+					c: "value"
+				}
+			}
+		};
+
+		const stack = ["a", "b", true];
+		const newValue = "new value";
+
+		expect(() => {
+			// @ts-ignore
+			update_object(obj, newValue, stack);
+		}).toThrowError("Invalid key type");
+	});
+});
+
+describe("skip_queue", () => {
+	const id = 0;
+	const config = config_response;
+
+	it("should not skip queue when global and dependency queue is enabled", () => {
+		config.enable_queue = true;
+		config.dependencies[id].queue = true;
+
+		const result = skip_queue(id, config_response);
+
+		expect(result).toBe(false);
+	});
+
+	it("should not skip queue when global queue is disabled and dependency queue is enabled", () => {
+		config.enable_queue = false;
+		config.dependencies[id].queue = true;
+
+		const result = skip_queue(id, config_response);
+
+		expect(result).toBe(false);
+	});
+
+	it("should should skip queue when global queue and dependency queue is disabled", () => {
+		config.enable_queue = false;
+		config.dependencies[id].queue = false;
+
+		const result = skip_queue(id, config_response);
+
+		expect(result).toBe(true);
+	});
+
+	it("should should skip queue when global queue is enabled and dependency queue is disabled", () => {
+		config.enable_queue = true;
+		config.dependencies[id].queue = false;
+
+		const result = skip_queue(id, config_response);
+
+		expect(result).toBe(true);
+	});
+});
+
+describe("post_message", () => {
+	afterEach(() => {
+		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();
+
+		global.window = {
+			// @ts-ignore
+			parent: {
+				postMessage: post_message_mock
+			}
+		};
+
+		const message_channel_mock = {
+			port1: {
+				onmessage: (handler) => {
+					onmessage = handler;
+				},
+				close: vi.fn()
+			},
+			port2: {}
+		};
+
+		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);
+
+		if (message_channel_mock.port1.onmessage) {
+			message_channel_mock.port1.onmessage({ data: test_data });
+		}
+
+		await expect(promise).resolves.toEqual(test_data);
+		expect(post_message_mock).toHaveBeenCalledWith(test_data, test_origin, [
+			message_channel_mock.port2
+		]);
+	});
+});

package/src/test/handlers.ts

@@ -0,0 +1,438 @@
+import { HttpResponse, http, RequestHandler } from "msw";
+import {
+	HOST_URL,
+	API_INFO_URL,
+	CONFIG_URL,
+	RUNTIME_URL,
+	SLEEPTIME_URL,
+	UPLOAD_URL,
+	BROKEN_CONNECTION_MSG
+} from "../constants";
+import {
+	response_api_info,
+	config_response,
+	whoami_response,
+	duplicate_response,
+	hardware_sleeptime_response,
+	discussions_response,
+	runtime_response
+} from "./test_data";
+
+const root_url = "https://huggingface.co";
+
+const direct_space_url = "https://hmb-hello-world.hf.space";
+const private_space_url = "https://hmb-secret-world.hf.space";
+
+const server_error_space_url = "https://hmb-server-error.hf.space";
+const upload_server_test_space_url = "https://hmb-server-test.hf.space";
+const server_error_reference = "hmb/server_error";
+
+const app_reference = "hmb/hello_world";
+const broken_app_reference = "hmb/bye_world";
+const duplicate_app_reference = "gradio/hello_world";
+const private_app_reference = "hmb/secret_world";
+const server_test_app_reference = "hmb/server_test";
+
+export const handlers: RequestHandler[] = [
+	// /host requests
+	http.get(`${root_url}/api/spaces/${app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				subdomain: "hmb-hello-world",
+				host: "https://hmb-hello-world.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/${broken_app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(null, {
+			status: 404,
+			headers: {
+				"Content-Type": "application/json",
+				hf_token: "hf_123"
+			}
+		});
+	}),
+	http.get(
+		`${root_url}/api/spaces/${private_app_reference}/${HOST_URL}`,
+		({ request }) => {
+			const token = request.headers.get("authorization")?.substring(7);
+
+			if (!token || token !== "hf_123") {
+				return new HttpResponse(null, {
+					status: 401,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				});
+			}
+
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: private_app_reference,
+					host: private_space_url
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${server_error_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-server-test",
+					host: "https://hmb-server-test.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${server_test_app_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-server-test",
+					host: "https://hmb-server-test.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	// /info requests
+	http.get(`${direct_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${upload_server_test_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${private_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${server_error_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// /config requests
+	http.get(`${direct_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${private_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-secret-world.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${upload_server_test_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-server-test.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${direct_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${server_error_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// /whoami requests
+	http.get(`${root_url}/api/whoami-v2`, () => {
+		return new HttpResponse(JSON.stringify(whoami_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json",
+				"hf-token": "hf_123"
+			}
+		});
+	}),
+	// /duplicate requests
+	http.post(
+		`${root_url}/api/spaces/${duplicate_app_reference}/duplicate`,
+		({ request }) => {
+			if (request.headers.get("authorization")?.substring(7) !== "hf_123") {
+				throw new HttpResponse(null, {
+					status: 401,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				});
+			}
+			return new HttpResponse(JSON.stringify(duplicate_response), {
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	// /sleeptime requests
+	http.post(`${root_url}/api/spaces/${app_reference}/${SLEEPTIME_URL}`, () => {
+		return new HttpResponse(JSON.stringify(hardware_sleeptime_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(
+		`${root_url}/api/spaces/${server_test_app_reference}/${SLEEPTIME_URL}`,
+		() => {
+			throw new HttpResponse(null, {
+				status: 500,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	// /runtime requests
+	http.get(
+		`${root_url}/api/spaces/${broken_app_reference}/${RUNTIME_URL}`,
+		() => {
+			return new HttpResponse(null, {
+				status: 404,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	http.get(`${root_url}/api/spaces/${app_reference}/${RUNTIME_URL}`, () => {
+		return new HttpResponse(JSON.stringify(hardware_sleeptime_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// queue requests
+	http.post(`${direct_space_url}/queue/join`, () => {
+		return new HttpResponse(JSON.stringify({ event_id: "123" }), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// upload requests
+	http.post(`${direct_space_url}/${UPLOAD_URL}`, () => {
+		return new HttpResponse(JSON.stringify(["lion.jpg"]), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${upload_server_test_space_url}/${UPLOAD_URL}`, () => {
+		throw new HttpResponse(JSON.parse("Internal Server Error"), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// discussions requests
+	http.head(`${root_url}/api/spaces/${app_reference}/discussions`, () => {
+		return new HttpResponse(JSON.stringify(discussions_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.head(
+		`${root_url}/api/spaces/${broken_app_reference}/discussions`,
+		() => {
+			throw new HttpResponse(
+				JSON.parse("Discussions are disabled for this repo"),
+				{
+					status: 403,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	// space requests
+	http.get(`${root_url}/api/spaces/${app_reference}`, () => {
+		return new HttpResponse(
+			JSON.stringify({ id: app_reference, runtime: runtime_response }),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/paused_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "PAUSED" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/building_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "BUILDING" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/stopped_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "STOPPED" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/failed_space`, () => {
+		throw new HttpResponse(null, {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// jwt requests
+	http.get(`${root_url}/api/spaces/${app_reference}/jwt`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				token: "jwt_123"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/${broken_app_reference}/jwt`, () => {
+		return new HttpResponse(null, {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// post_data requests
+	http.post(`${direct_space_url}`, () => {
+		return new HttpResponse(JSON.stringify({}), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${private_space_url}`, () => {
+		return new HttpResponse(JSON.stringify(BROKEN_CONNECTION_MSG), {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// heartbeat requests
+	http.get(`*/heartbeat/*`, () => {
+		return new HttpResponse(null, {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	})
+];