import json import os import sys import threading import time import unittest from pathlib import Path from types import SimpleNamespace from unittest import mock ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT)) sys.path.insert(0, str(ROOT / "tests")) os.environ["LABS_FALLBACK_SIGNING_KEY"] = "unit-signing-key" os.environ.pop("SPACE_ID", None) os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False") import fallback_stubs # noqa: E402 fallback_stubs.install() import gradio as gr # noqa: E402 import app # noqa: E402 PAYLOAD = {"glb_name": "model.glb", "glb_b64": "aGFybmVzcw=="} QUOTA_MESSAGE = "You have exceeded your ZeroGPU runs limit. Try again in 1 hour." BAKE = "gpu_task:bake" def request(session="visitor-a"): return SimpleNamespace(session_hash=session, headers={"x-ip-token": "visitor-token"}) def fresh_state(**extra): return {"runtime": "original", "marker": "state-0", **extra} def labs_events(logs, name): rows = [json.loads(line.split("LABS_EVENT ", 1)[1]) for line in logs.output if "LABS_EVENT " in line] return [row for row in rows if row["event"] == name] class GatedBake: def __init__(self): self.release = threading.Event() self.started = threading.Event() self.sizes = [] self.active = 0 self.overlapped = False def __call__(self, state, texture_size): self.active += 1 self.overlapped |= self.active > 1 self.sizes.append(texture_size) self.started.set() self.release.wait(5) self.active -= 1 return {"glb": texture_size} class PrebakeTestCase(unittest.TestCase): def setUp(self): fallback_stubs.GPU_ATTEMPTS.clear() fallback_stubs.GPU_CALLS.clear() fallback_stubs.GPU_GATE["error"] = None app.FLIGHTS = app.BakeFlights() patches = [ mock.patch.object(app, "save_export_payload", side_effect=lambda glb, _progress: dict(PAYLOAD, size=glb["glb"])), mock.patch.object(app, "current_session_tag", return_value=app.session_tag("visitor-a")), ] for patch in patches: patch.start() self.addCleanup(patch.stop) def prebake_in_background(self, state, texture_size=1024): worker = threading.Thread(target=app.prebake_glb, args=(state, 0.95, texture_size, request())) worker.start() self.addCleanup(worker.join, 5) return worker class PrebakeDedupe(PrebakeTestCase): def test_click_after_a_finished_prebake_is_served_without_a_second_allocation(self): state = fresh_state() with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}), \ self.assertLogs("usage_log", "INFO") as logs: app.prebake_glb(state, 0.95, 1024, request()) status, payload = app.extract_model(state, 0.95, 1024, None) self.assertEqual(payload["size"], 1024) self.assertIn("Finalizing", status["value"]) self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "hit") self.assertTrue(labs_events(logs, "prebake_done")[0]["ip_token"]) gpu_calls = [json.loads(line.split("GPU_CALL ", 1)[1]) for line in logs.output if "GPU_CALL " in line] self.assertEqual([call.get("prebake") for call in gpu_calls], [True]) def test_click_during_the_prebake_waits_for_it_instead_of_allocating_again(self): state, bake = fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake), \ self.assertLogs("usage_log", "INFO") as logs: worker = self.prebake_in_background(state) self.assertTrue(bake.started.wait(5)) progress = mock.Mock() threading.Timer(0.2, bake.release.set).start() status, payload = app.extract_model(state, 0.95, 1024, progress) worker.join(5) self.assertEqual(payload["size"], 1024) self.assertEqual(bake.sizes, [1024]) self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) self.assertRegex(progress.call_args.kwargs["desc"], "(?i)textur|glb|bak") self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "joined") def test_a_changed_size_bakes_fresh_after_the_prebake_without_overlapping_it(self): state, bake = fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake): worker = self.prebake_in_background(state) self.assertTrue(bake.started.wait(5)) threading.Timer(0.2, bake.release.set).start() status, payload = app.extract_model(state, 0.95, 2048, None) worker.join(5) self.assertEqual(payload["size"], 2048) self.assertEqual(bake.sizes, [1024, 2048]) self.assertFalse(bake.overlapped) self.assertEqual(state[app.GLB_SETTINGS_KEY]["texture_size"], 2048) self.assertFalse(state[app.GLB_PREBAKED_KEY]) def test_a_second_prebake_of_the_same_generation_does_not_allocate(self): state = fresh_state() with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}): app.prebake_glb(state, 0.95, 1024, request()) app.prebake_glb(state, 0.95, 1024, request()) self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) def test_prebake_joins_nothing_and_skips_when_a_click_bake_is_running(self): state, bake = fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake): click = threading.Thread(target=app.extract_model, args=(state, 0.95, 1024, None)) click.start() self.assertTrue(bake.started.wait(5)) started = time.perf_counter() app.prebake_glb(state, 0.95, 1024, request()) self.assertLess(time.perf_counter() - started, 1) bake.release.set() click.join(5) self.assertEqual(bake.sizes, [1024]) class PrebakeCancellation(PrebakeTestCase): def test_new_generation_discards_the_stale_prebake(self): state, bake = fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake): worker = self.prebake_in_background(state) self.assertTrue(bake.started.wait(5)) app.reset_fallback_state(request()) self.assertEqual(app.FLIGHTS.discard_session(app.session_tag("visitor-a")), 0) bake.release.set() worker.join(5) def test_other_sessions_keep_their_prebake(self): state, bake = fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake): worker = self.prebake_in_background(state) self.assertTrue(bake.started.wait(5)) app.reset_fallback_state(request("visitor-b")) self.assertEqual(app.FLIGHTS.discard_session(app.session_tag("visitor-a")), 1) bake.release.set() worker.join(5) def test_prebakes_are_capped_and_never_evict_running_work(self): app.FLIGHTS = app.BakeFlights(prebake_limit=1) first, second, bake = fresh_state(), fresh_state(), GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=bake): worker = self.prebake_in_background(first) self.assertTrue(bake.started.wait(5)) app.prebake_glb(second, 0.95, 1024, request("visitor-b")) bake.release.set() worker.join(5) self.assertEqual(bake.sizes, [1024]) self.assertIsNotNone(first.get(app.GLB_PAYLOAD_KEY)) self.assertIsNone(second.get(app.GLB_PAYLOAD_KEY)) class PrebakeGuards(PrebakeTestCase): def test_switch_off_never_allocates(self): with mock.patch.object(app, "PREBAKE_GLB", False), mock.patch.object(app, "_prepare_glb") as prepare: app.prebake_glb(fresh_state(), 0.95, 1024, request()) prepare.assert_not_called() self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) def test_pro_fallback_generations_are_not_prebaked(self): with mock.patch.object(app, "_prepare_glb") as prepare: app.prebake_glb(fresh_state(**{app.GENERATED_VIA_KEY: "pro"}), 0.95, 1024, request()) prepare.assert_not_called() self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) def run_pro(self, frames=("frame",), state=None): state = fresh_state(**{app.GLB_REQUESTED_KEY: {"simplify": 0.95, "texture_size": 1024}}) if state is None else state entry = SimpleNamespace(args=(object(), 42, 7.5, 12, 3.0, 12, 1024), session_hash="visitor-a") with mock.patch.object(app, "generate_preview_frames", return_value=(list(frames), state)), \ mock.patch.object(app, "write_preview_video", return_value="preview.webm"), \ mock.patch.object(app, "save_run_async"), \ mock.patch.object(app, "get_preview_settings", return_value=(0, 0, 15, 0)): return app.run_pro_generate(entry, request()) def wait_for_bakes(self, count): deadline = time.time() + 5 while len(fallback_stubs.GPU_CALLS) < count and time.time() < deadline: time.sleep(0.01) def test_pro_generation_prebakes_under_its_own_request_and_the_click_is_a_hit(self): with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: {"glb": size}), \ self.assertLogs("usage_log", "INFO") as logs: _video, state = self.run_pro() self.wait_for_bakes(1) deadline = time.time() + 5 while app.GLB_PAYLOAD_KEY not in state and time.time() < deadline: time.sleep(0.01) status, payload = app.extract_model(state, 0.95, 1024, None) self.assertEqual(payload["size"], 1024) self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) self.assertEqual(labs_events(logs, "prebake_done")[0]["via"], "pro") self.assertEqual(labs_events(logs, "glb_done")[0]["prebake"], "hit") def test_click_during_the_pro_prebake_joins_it(self): bake = GatedBake() with mock.patch.object(app, "_prepare_glb", side_effect=lambda _s, size: bake(_s, size)): _video, state = self.run_pro() self.assertTrue(bake.started.wait(5)) clicked = {} click = threading.Thread(target=lambda: clicked.update(result=app.extract_model(state, 0.95, 1024, None))) click.start() time.sleep(0.1) bake.release.set() click.join(5) self.assertEqual(clicked["result"][1]["size"], 1024) self.assertEqual(fallback_stubs.GPU_CALLS, [BAKE]) def test_failed_or_disabled_pro_previews_do_not_prebake(self): with mock.patch.object(app, "_prepare_glb") as prepare: self.run_pro(frames=()) with mock.patch.object(app, "PREBAKE_GLB", False): self.run_pro() time.sleep(0.1) prepare.assert_not_called() self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) def test_pro_generation_marks_its_state(self): entry = SimpleNamespace(args=(object(), 42, 7.5, 12, 3.0, 12, 1024), session_hash="visitor-a") with mock.patch.object(app, "generate_preview_frames", return_value=(None, fresh_state())): _video, state = app.run_pro_generate(entry, request()) self.assertEqual(state[app.GENERATED_VIA_KEY], "pro") def test_quota_denied_prebake_leaves_no_error_and_the_click_still_routes_normally(self): state = fresh_state() fallback_stubs.GPU_GATE["error"] = gr.Error(QUOTA_MESSAGE) app.prebake_glb(state, 0.95, 1024, request()) self.assertNotIn(app.GLB_ERROR_KEY, state) status, payload = app.extract_model(state, 0.95, 1024, None) self.assertIsNone(payload) self.assertTrue(app.export_quota_denied(state, status["value"])) self.assertEqual(fallback_stubs.GPU_ATTEMPTS, [BAKE, BAKE]) def test_invalid_size_is_refused_before_allocation(self): app.prebake_glb(fresh_state(), 0.95, 999, request()) self.assertEqual(fallback_stubs.GPU_ATTEMPTS, []) class PrebakeWiring(unittest.TestCase): def test_prebake_follows_every_generation_flow_and_stays_off_the_api(self): config = app.demo.get_config_file() deps = config["dependencies"] prebakes = [dep for dep in deps if (dep.get("api_name") or "").startswith("prebake_glb")] self.assertEqual(len(prebakes), 3) self.assertTrue(all(dep["api_visibility"] == "private" for dep in prebakes)) self.assertTrue(all(dep["show_progress"] == "hidden" and not dep["outputs"] for dep in prebakes)) by_id = {dep["id"]: dep for dep in deps} self.assertTrue(all(by_id[dep["trigger_after"]]["api_name"].startswith("enable_model_exports") for dep in prebakes)) self.assertFalse([name for name in app.demo.get_api_info()["named_endpoints"] if "prebake" in name]) if __name__ == "__main__": unittest.main()