File size: 4,650 Bytes
5189638
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
"""Gradio Server and synchronous ZeroGPU generation contracts."""

from __future__ import annotations

import io
import os
import tempfile
import unittest
import wave
from pathlib import Path
from types import SimpleNamespace

# Importing app builds the module-level hosted app, whose storage empties its
# OUTPUT_DIR on start. Never let a test run wipe the developer's ./outputs.
os.environ["OUTPUT_DIR"] = tempfile.mkdtemp(prefix="rickroll-test-outputs-")

try:
    from app import create_zero_gpu_app
except ModuleNotFoundError as exc:  # optional hosted dependencies are absent locally
    raise unittest.SkipTest(f"Hosted Gradio dependencies unavailable: {exc}") from exc

from fastapi.testclient import TestClient

from backend.storage import StorageError

class _AudioRuntime:
    def __init__(self) -> None:
        self.last_request: dict | None = None

    def initialize(self) -> None:
        return None

    def info(self) -> dict:
        return {
            "ready": True,
            "model": {"loaded": True},
            "vae": {"loaded": True},
            "adapter": {"loaded": True},
        }

    def generate(
        self,
        lyrics: str,
        style: str,
        stage: Path,
        progress,
        *,
        duration_seconds: int = 60,
        input_audio_path: Path | None = None,
    ) -> dict:
        self.last_request = {
            "style": style,
            "duration_seconds": duration_seconds,
            "input_audio": input_audio_path.read_bytes() if input_audio_path else None,
        }
        progress({"stage": "synthesizing", "percent": 50})
        output = Path(stage) / "audio.wav"
        with wave.open(str(output), "wb") as audio:
            audio.setnchannels(2)
            audio.setsampwidth(2)
            audio.setframerate(48_000)
            audio.writeframes(bytes(48_000 * 2 * 2 // 10))
        return {
            "audio_path": str(output),
            "metadata": {
                "requested_duration": duration_seconds,
                "generation_mode": "text",
            },
        }


class ZeroGpuAppTest(unittest.TestCase):
    def test_gradio_transport_runs_and_publishes_for_the_cookie_session(self) -> None:
        with tempfile.TemporaryDirectory() as directory:
            runtime = _AudioRuntime()
            app = create_zero_gpu_app(runtime=runtime, output_dir=directory)
            with TestClient(app, base_url="https://testserver") as client:
                session_response = client.get("/api/v1/tracks")
                health = client.get("/api/v1/health").json()
                request = SimpleNamespace(
                    headers={"host": "testserver", "origin": "https://testserver"},
                    cookies={"yue_session": client.cookies.get("yue_session")},
                )

                job = app.state.zero_gpu_generate("Neon signal", "Cyber synth", 90, request)
                track = client.get(f"/api/v1/tracks/{job['track_id']}")

                self.assertEqual(session_response.status_code, 200)
                self.assertEqual(health["generation_transport"], "gradio")
                self.assertTrue(health["ready"])
                self.assertEqual(job["status"], "completed")
                self.assertEqual(track.status_code, 200)
                self.assertEqual(track.json()["lyrics"], "Neon signal")
                self.assertEqual(track.json()["metadata"]["requested_duration"], 90)
                self.assertEqual(runtime.last_request["duration_seconds"], 90)
                self.assertEqual(runtime.last_request["style"], "Cyber synth")

    def test_worker_artifact_is_published_only_by_parent_state(self) -> None:
        with tempfile.TemporaryDirectory() as directory:
            app = create_zero_gpu_app(runtime=_AudioRuntime(), output_dir=directory)
            with TestClient(app, base_url="https://testserver"):
                session, _ = app.state.session_manager.get_or_create(None)
                job = app.state.jobs.submit(session_id=session.id, lyrics="Parent index", style="Cyber synth")
                job, stage = app.state.jobs.begin(job.id, session.id)

                result = app.state.jobs.generate_artifact(stage, job.lyrics, job.style)

                self.assertEqual(app.state.storage.list(session.id), [])
                completed = app.state.jobs.complete(job.id, session.id, stage, result)
                stored = app.state.storage.get(completed.track_id, session.id)
                self.assertEqual(completed.status, "completed")
                self.assertEqual(stored.payload["lyrics"], "Parent index")




if __name__ == "__main__":
    unittest.main()