File size: 7,916 Bytes
0d8ca70
 
 
 
 
 
 
 
 
 
 
 
 
 
 
18bfeb9
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0d8ca70
 
 
18bfeb9
0d8ca70
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3048bbe
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0d8ca70
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
"""Actual FastAPI/Gradio routes; CPU media only, no simulated inference."""
import copy
import json
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

import workflow_artifacts as a
from cpu_preview import cpu_core
from workflow_ui import create_workflow
from workflow_nodes import Nodes
from workflow_media import output_file


def test_gpu_registration_does_not_duplicate_canvas_load_events_or_app_routes():
    # Construction probe only: never substitutes GPU inference in production.
    base, base_app = create_workflow(cpu_core())
    core = cpu_core()
    def registration_probe(value: str):
        return value
    core.render_all_segments = registration_probe
    registered, app = create_workflow(core, register_gpu=True)
    def load_count(demo):
        return sum(any(event == "load" for _, event in dep["targets"])
                   for dep in demo.get_config_file()["dependencies"])
    try:
        assert load_count(registered) == load_count(base)
        assert len(registered.fns) == len(base.fns) + 1
        # Launch will add these exactly once; custom routes are already present.
        assert not any(getattr(r, "path", None) == "/config" for r in app.routes)
        app = type(app).create_app(registered, app=app)
        assert sum(m.cls.__name__ == "BrotliMiddleware" for m in app.user_middleware) == 1
        assert sum(m.cls.__name__ == "CustomCORSMiddleware" for m in app.user_middleware) == 1
        with TestClient(app) as client:
            config = client.get("/config").json()
            ids = {c["id"] for c in config["components"]}
            assert ids <= set(app.get_blocks().blocks)
            canvas = next(c for c in config["components"] if c["type"] == "workflowcanvas")
            result = client.post("/gradio_api/component_server", json={
                "component_id": canvas["id"], "fn_name": "get_workflow_key",
                "data": {}, "session_hash": "startup-regression"})
            assert result.status_code == 200
    finally:
        registered.close()
        base.close()


@pytest.fixture(scope="module")
def client():
    demo, app = create_workflow(cpu_core())
    app = type(app).create_app(demo, app=app)
    # Production launch adds this path. TestClient does not call launch().
    demo.allowed_paths = [str(a.PUBLIC)]
    with TestClient(app) as c:
        yield c
    demo.close()


def test_native_config_routes_and_canvas_default(client):
    response = client.get("/", follow_redirects=False)
    assert response.status_code == 307 and "ui=canvas" in response.headers["location"]
    assert a.ID.fullmatch(client.cookies["vm_workspace"])
    config = client.get("/config").json()
    assert config["version"] == "6.30.0"
    assert any(c["type"] == "workflowcanvas" for c in config["components"])
    # Bound-function endpoints are intentionally undocumented; /info lists
    # public generated-pipeline endpoints, while config contains both.
    assert client.get("/gradio_api/info").status_code == 200
    names = {d["api_name"] for d in config["dependencies"]}
    for name in Nodes(cpu_core()).bindings():
        assert "predict_fn_" + name.replace(" ", "_") in names


def test_canvas_redirect_keeps_browser_https_behind_hf_proxy(client):
    # Reproduce HF's proxy boundary: Python receives HTTP but the embedding
    # browser is on HTTPS. Never derive the redirect scheme from this scope.
    from urllib.parse import urljoin, parse_qs, urlsplit
    response = client.get("http://fffiloni-viggle-mine-workflow.hf.space/?__theme=light",
                          follow_redirects=False)
    assert response.status_code == 307
    location = response.headers["location"]
    assert location.startswith("/?") and not location.startswith("//")
    browser_target = urljoin("https://fffiloni-viggle-mine-workflow.hf.space/", location)
    assert urlsplit(browser_target).scheme == "https"
    assert parse_qs(urlsplit(browser_target).query) == {"__theme":["light"],"ui":["canvas"]}
    assert response.headers["cache-control"] == "no-store"
    # HTML rendering requires launch()'s theme setup; the real-server smoke
    # follows this redirect and checks the resulting page separately.


def test_source_picker_bridge_and_legacy_retention(client, prepared, point_payload):
    ident = prepared["id"]
    page = client.get("/picker/", params={"session": ident})
    assert page.status_code == 200 and "Save points &amp; continue" not in page.text
    assert "Save points & continue" in page.text
    model = client.get(f"/picker/api/session/{ident}").json()
    assert model["coordinate_space"] == "normalized_source"
    assert len(model["anchors"]) == 3
    assert client.get(model["anchors"][0]["url"]).headers["content-type"] == "image/png"
    saved = client.post(f"/picker/api/session/{ident}/points", json=point_payload)
    assert saved.status_code == 200 and saved.json()["saved"]
    assert a.points(prepared)["anchors"] == saved.json()["anchors"]
    # No queue/SSE is involved in saving or reloading the picker.
    again = client.get(f"/picker/api/session/{ident}").json()
    assert again["anchors"][0]["points"] == point_payload["anchors"][0]["points"]
    assert client.get("/picker/").status_code == 200
    fallback = client.get("/picker/legacy/", params={"session":ident})
    assert fallback.status_code == 200 and "Save points to Workflow" in fallback.text
    assert prepared["manifest_path"] in fallback.text and ident in fallback.text
    legacy = client.get("/picker/api/manifest", params={"path": prepared["manifest_path"]})
    assert legacy.status_code == 200
    assert client.get(legacy.json()["anchors"][0]["url"]).status_code == 200
    wrong = copy.deepcopy(point_payload); wrong["coordinate_space"] = "stabilized"
    assert client.post(f"/picker/api/session/{ident}/points", json=wrong).status_code == 400
    assert client.post(f"/picker/api/session/{ident}/points", json=point_payload,
                       headers={"origin":"https://another.example"}).status_code == 403
    assert client.get(f"/artifact/{ident}").json()["kind"] == "prepared"


def test_recovery_browser_extracts_exact_stabilized_input_frame(client, camera, prepared):
    # A manifest fixture stands in for a completed generation. Only the frame
    # extraction below is real; no assertion here implies GPU generation.
    passed = a.create("pass_a", {"camera_id":camera["id"], "preparation_id":prepared["id"],
        "stabilized_generated":camera["stable_video"], "final_video":prepared["meta"]["normalized"]},
        files=[camera["stable_video"]], parents=[camera["id"]])
    ident = passed["id"]
    data = client.get(f"/recovery/api/{ident}").json()
    assert data["coordinate_space"] == "stabilized"
    assert data["url"] == output_file(camera["stable_video"])["url"]
    assert data["url"] != output_file(prepared["meta"]["normalized"])["url"]
    assert client.get("/recovery/", params={"checkpoint":ident}).status_code == 200
    response = client.post(f"/recovery/api/{ident}/select", json={"time":1.501})
    assert response.status_code == 200
    selected = response.json()
    assert selected["time"] == 1.5 and selected["frame"] == 30
    artifact = a.load(Nodes(cpu_core()).prepare_recovery(a.card(passed,"Saved A")), "recovery")
    assert artifact["reacq_time"] == selected["time"] and artifact["pass_a_id"] == ident
    from PIL import Image
    import media
    expected = a.PUBLIC / "recovery-exact-frame.png"
    media.extract_frame(camera["stable_video"], expected, 30)
    assert Image.open(expected).tobytes() == Image.open(artifact["candidate"]).tobytes()
    assert client.post(f"/recovery/api/{ident}/select", json={"time":999}).status_code == 400
    assert client.post(f"/recovery/api/{ident}/select", json={"time":data["start"]}).status_code == 400
    assert client.post(f"/recovery/api/{ident}/select", json={"time":data["end"]}).status_code == 400