@gradio/client 0.16.0 → 0.18.0

package/src/test/init.test.ts

@@ -0,0 +1,139 @@
+import {
+	describe,
+	beforeAll,
+	afterEach,
+	afterAll,
+	test,
+	expect,
+	vi
+} from "vitest";
+
+import { Client, client, duplicate } from "..";
+import { transformed_api_info, config_response } from "./test_data";
+import { initialise_server } from "./server";
+import { CONFIG_ERROR_MSG, SPACE_METADATA_ERROR_MSG } from "../constants";
+
+const app_reference = "hmb/hello_world";
+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();
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("Client class", () => {
+	describe("initialisation", () => {
+		test("backwards compatibility of client using deprecated syntax", async () => {
+			const app = await client(app_reference);
+			expect(app.config).toEqual(config_response);
+		});
+		test("connecting to a running app with a space reference", async () => {
+			const app = await Client.connect(app_reference);
+			expect(app.config).toEqual(config_response);
+		});
+
+		test("connecting to a running app with a direct app URL", async () => {
+			const app = await Client.connect(direct_app_reference);
+			expect(app.config).toEqual(config_response);
+		});
+
+		test("connecting successfully to a private running app with a space reference", async () => {
+			const app = await Client.connect("hmb/secret_world", {
+				hf_token: "hf_123"
+			});
+
+			expect(app.config).toEqual({
+				...config_response,
+				root: "https://hmb-secret-world.hf.space"
+			});
+		});
+
+		test("connecting successfully to a private running app with a direct app URL ", async () => {
+			const app = await Client.connect(secret_direct_app_reference, {
+				hf_token: "hf_123"
+			});
+
+			expect(app.config).toEqual({
+				...config_response,
+				root: "https://hmb-secret-world.hf.space"
+			});
+		});
+
+		test("unsuccessfully attempting to connect to a private running app", async () => {
+			await expect(
+				Client.connect("hmb/secret_world", {
+					hf_token: "hf_bad_token"
+				})
+			).rejects.toThrow(CONFIG_ERROR_MSG);
+		});
+
+		test("viewing the api info of a running app", async () => {
+			const app = await Client.connect(app_reference);
+			expect(await app.view_api()).toEqual(transformed_api_info);
+		});
+
+		test("viewing the api info of a non-existent app", async () => {
+			const app = Client.connect(broken_app_reference);
+			await expect(app).rejects.toThrow(CONFIG_ERROR_MSG);
+		});
+	});
+
+	describe("duplicate", () => {
+		test("backwards compatibility of duplicate using deprecated syntax", async () => {
+			const app = await duplicate("gradio/hello_world", {
+				hf_token: "hf_123",
+				private: true,
+				hardware: "cpu-basic"
+			});
+
+			expect(app.config).toEqual(config_response);
+		});
+
+		test("creating a duplicate of a running app", async () => {
+			const duplicate = await Client.duplicate("gradio/hello_world", {
+				hf_token: "hf_123",
+				private: true,
+				hardware: "cpu-basic"
+			});
+
+			expect(duplicate.config).toEqual(config_response);
+		});
+
+		test("creating a duplicate of a running app without a token", async () => {
+			const duplicate = Client.duplicate("gradio/hello_world", {
+				private: true,
+				hardware: "cpu-basic"
+			});
+
+			await expect(duplicate).rejects.toThrow("Error: Unauthorized");
+		});
+
+		test("creating a duplicate of a broken app", async () => {
+			const duplicate = Client.duplicate(broken_app_reference);
+
+			await expect(duplicate).rejects.toThrow(SPACE_METADATA_ERROR_MSG);
+		});
+	});
+
+	describe("overriding the Client class", () => {
+		test("overriding methods on the Client class", async () => {
+			const mocked_fetch = vi.fn(
+				(input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+					return Promise.resolve(
+						new Response(JSON.stringify({ data: "test" }))
+					);
+				}
+			);
+
+			class CustomClient extends Client {
+				fetch = mocked_fetch;
+			}
+
+			await CustomClient.connect("hmb/hello_world");
+			expect(mocked_fetch).toHaveBeenCalled();
+		});
+	});
+});

package/src/test/init_helpers.test.ts

@@ -0,0 +1,94 @@
+import {
+	resolve_root,
+	get_jwt,
+	determine_protocol
+} from "../helpers/init_helpers";
+import { initialise_server } from "./server";
+import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
+
+const server = initialise_server();
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("resolve_root", () => {
+	it('should return the base URL if the root path starts with "http://"', () => {
+		const base_url = "https://huggingface.co";
+		const root_path = "https://hmb-hello-world.hf.space";
+		const prioritize_base = true;
+		const result = resolve_root(base_url, root_path, prioritize_base);
+		expect(result).toBe(base_url);
+	});
+
+	it('should return the base URL if the root path starts with "https://"', () => {
+		const base_url = "https://huggingface.co";
+		const root_path = "https://hmb-hello-world.hf.space";
+		const prioritize_base = true;
+		const result = resolve_root(base_url, root_path, prioritize_base);
+		expect(result).toBe(base_url);
+	});
+});
+
+describe("get_jwt", () => {
+	it("should return a valid JWT token when the API call is successful", async () => {
+		const space = "hmb/hello_world";
+		const token = "hf_123";
+		const expected_jwt = "jwt_123";
+
+		const result = await get_jwt(space, token);
+
+		expect(result).toBe(expected_jwt);
+	});
+
+	it("should return false when the API call fails", async () => {
+		const space = "hmb/bye_world";
+		const token = "hf_123";
+
+		const result = await get_jwt(space, token);
+
+		expect(result).toBe(false);
+	});
+});
+
+describe("determine_protocol", () => {
+	it('should return the correct protocols and host when the endpoint starts with "http"', () => {
+		const endpoint = "http://huggingface.co";
+		const result = determine_protocol(endpoint);
+		expect(result).toEqual({
+			ws_protocol: "ws",
+			http_protocol: "http:",
+			host: "huggingface.co"
+		});
+	});
+
+	it('should return the correct protocols and host when the endpoint starts with "https"', () => {
+		const endpoint = "https://huggingface.co";
+		const result = determine_protocol(endpoint);
+		expect(result).toEqual({
+			ws_protocol: "wss",
+			http_protocol: "https:",
+			host: "huggingface.co"
+		});
+	});
+
+	it('should return the correct protocols and host when the endpoint starts with "file"', () => {
+		const endpoint = "file:///path/to/app.html";
+		const result = determine_protocol(endpoint);
+		expect(result).toEqual({
+			ws_protocol: "ws",
+			http_protocol: "http:",
+			host: "lite.local"
+		});
+	});
+
+	it('should return the default protocols and host when the endpoint does not start with "http" or "file"', () => {
+		const endpoint = "huggingface.co";
+		const result = determine_protocol(endpoint);
+		expect(result).toEqual({
+			ws_protocol: "wss",
+			http_protocol: "https:",
+			host: "huggingface.co"
+		});
+	});
+});

package/src/test/mock_eventsource.ts

@@ -0,0 +1,11 @@
+import { vi } from "vitest";
+
+Object.defineProperty(window, "EventSource", {
+	writable: true,
+	value: vi.fn().mockImplementation(() => ({
+		close: vi.fn(() => {}),
+		addEventListener: vi.fn(),
+		onmessage: vi.fn((_event: MessageEvent) => {}),
+		onerror: vi.fn((_event: Event) => {})
+	}))
+});

package/src/test/post_data.test.ts

@@ -0,0 +1,45 @@
+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());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("post_data", () => {
+	it("should send a POST request with the correct headers and body", async () => {
+		const app = await Client.connect("hmb/hello_world");
+		const config = app.config;
+		const url = config?.root;
+		const body = { data: "test" };
+
+		if (!url) {
+			throw new Error("No URL provided");
+		}
+
+		const [response, status] = await app.post_data(url, body);
+
+		expect(response).toEqual({});
+		expect(status).toBe(200);
+	});
+
+	it("should handle network errors", async () => {
+		const app = await Client.connect("hmb/secret_world", {
+			hf_token: "hf_123"
+		});
+
+		const url = "https://hmb-secret-world.hf.space";
+
+		if (!url) {
+			throw new Error("No URL provided");
+		}
+
+		const [response, status] = await app.post_data(url, {});
+
+		expect(response).toEqual(BROKEN_CONNECTION_MSG);
+		expect(status).toBe(500);
+	});
+});

package/src/test/server.ts

@@ -0,0 +1,6 @@
+import { setupServer } from "msw/node";
+import { handlers } from "./handlers";
+
+export function initialise_server(): any {
+	return setupServer(...handlers);
+}

package/src/test/spaces.test.ts

@@ -0,0 +1,145 @@
+import { SPACE_STATUS_ERROR_MSG } from "../constants";
+import {
+	discussions_enabled,
+	get_space_hardware,
+	set_space_timeout,
+	check_space_status
+} from "../helpers/spaces";
+import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
+
+import { initialise_server } from "./server";
+import { hardware_sleeptime_response } from "./test_data";
+import { vi } from "vitest";
+
+const server = initialise_server();
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("set_space_timeout", () => {
+	it("should set the sleep timeout for a space", async () => {
+		const space_id = "hmb/hello_world";
+		const timeout = 60;
+		const hf_token = "hf_123";
+
+		const response = await set_space_timeout(space_id, timeout, hf_token);
+
+		expect(response).toEqual(hardware_sleeptime_response);
+	});
+
+	it("should throw an error if the fetch call fails", async () => {
+		const space_id = "hmb/server_test";
+		const timeout = 60;
+		const hf_token = "hf_123";
+
+		await expect(
+			set_space_timeout(space_id, timeout, hf_token)
+		).rejects.toThrow(
+			"Could not set sleep timeout on duplicated Space. Please visit *ADD HF LINK TO SETTINGS* to set a timeout manually to reduce billing charges."
+		);
+	});
+});
+
+describe("get_space_hardware", () => {
+	it("should return the current hardware for a space", async () => {
+		const space_id = "hmb/hello_world";
+		const hf_token = "hf_123";
+
+		const hardware = await get_space_hardware(space_id, hf_token);
+		expect(hardware).toEqual(hardware_sleeptime_response.hardware.current);
+	});
+
+	it("should throw an error if the fetch call fails", async () => {
+		const space_id = "hmb/bye_world";
+
+		await expect(get_space_hardware(space_id)).rejects.toThrow(
+			"Space hardware could not be obtained."
+		);
+	});
+});
+
+describe("discussions_enabled", () => {
+	it("should return true if discussions are enabled for the space", async () => {
+		const space_id = "hmb/hello_world";
+		const result = await discussions_enabled(space_id);
+		expect(result).toBe(true);
+	});
+
+	it("should return false if discussions are disabled for the space", async () => {
+		const space_id = "hmb/bye_world";
+		const result = await discussions_enabled(space_id);
+		expect(result).toBe(false);
+	});
+});
+
+describe("check_space_status", () => {
+	const status_callback = vi.fn();
+
+	it("should handle a successful response with RUNNING stage", async () => {
+		const id = "hmb/hello_world";
+		const type = "space_name";
+
+		await check_space_status(id, type, status_callback);
+		expect(status_callback).toHaveBeenCalledWith({
+			status: "running",
+			load_status: "complete",
+			message: "",
+			detail: "RUNNING"
+		});
+	});
+
+	it("should handle a successful response with PAUSED stage", async () => {
+		const id = "hmb/paused_space";
+		const type = "space_name";
+
+		await check_space_status(id, type, status_callback);
+		expect(status_callback).toHaveBeenCalledWith({
+			status: "paused",
+			load_status: "error",
+			message:
+				"This space has been paused by the author. If you would like to try this demo, consider duplicating the space.",
+			detail: "PAUSED",
+			discussions_enabled: true
+		});
+	});
+
+	it("should handle a successful response with BUILDING stage", async () => {
+		const id = "hmb/building_space";
+		const type = "space_name";
+
+		await check_space_status(id, type, status_callback);
+		expect(status_callback).toHaveBeenCalledWith({
+			status: "building",
+			load_status: "pending",
+			message: "Space is building...",
+			detail: "BUILDING"
+		});
+	});
+
+	it("should handle a successful response with STOPPED stage", async () => {
+		const id = "hmb/stopped_space";
+		const type = "space_name";
+
+		await check_space_status(id, type, status_callback);
+		expect(status_callback).toHaveBeenCalledWith({
+			status: "sleeping",
+			load_status: "pending",
+			message: "Space is asleep. Waking it up...",
+			detail: "STOPPED"
+		});
+	});
+
+	it("should handle a failed response", async () => {
+		const id = "hmb/failed_space";
+		const type = "space_name";
+
+		await check_space_status(id, type, status_callback);
+		expect(status_callback).toHaveBeenCalledWith({
+			status: "error",
+			load_status: "error",
+			message: SPACE_STATUS_ERROR_MSG,
+			detail: "NOT_FOUND"
+		});
+	});
+});

package/src/test/stream.test.ts

@@ -0,0 +1,67 @@
+import { vi } from "vitest";
+import { Client } from "../client";
+import { initialise_server } from "./server";
+
+import { describe, it, expect, afterEach } from "vitest";
+import "./mock_eventsource.ts";
+
+const server = initialise_server();
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("open_stream", () => {
+	let mock_eventsource: any;
+	let app: any;
+
+	beforeEach(async () => {
+		app = await Client.connect("hmb/hello_world");
+		app.stream_factory = vi.fn().mockImplementation(() => {
+			mock_eventsource = new EventSource("");
+			return mock_eventsource;
+		});
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should throw an error if config is not defined", () => {
+		app.config = undefined;
+
+		expect(() => {
+			app.open_stream();
+		}).toThrow("Could not resolve app config");
+	});
+
+	it("should connect to the SSE endpoint and handle messages", async () => {
+		app.open_stream();
+
+		const eventsource_mock_call = app.stream_factory.mock.calls[0][0];
+
+		expect(eventsource_mock_call.href).toMatch(
+			/https:\/\/hmb-hello-world\.hf\.space\/queue\/data\?session_hash/
+		);
+
+		expect(app.stream_factory).toHaveBeenCalledWith(eventsource_mock_call);
+
+		const onMessageCallback = mock_eventsource.onmessage;
+		const onErrorCallback = mock_eventsource.onerror;
+
+		const message = { msg: "hello jerry" };
+
+		onMessageCallback({ data: JSON.stringify(message) });
+		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) });
+		expect(app.stream_status.open).toBe(false);
+
+		onErrorCallback({ data: JSON.stringify("404") });
+		expect(app.stream_status.open).toBe(false);
+	});
+});