Files
aigc-home/calliope-backend/tests/test_workflow_library.py
T

286 lines
12 KiB
Python

"""HEL-892: offline catalogue completeness, preservation and conservative conversion."""
from __future__ import annotations
import json
import sqlite3
from pathlib import Path
import pytest
from calliope.comfyui.client import ComfyUIClient
from calliope.comfyui.library import import_library, load_snapshot, migrate_library, rollback_batch
from calliope.comfyui.output_map import auto_output_map
from calliope.comfyui.ui2api import convert
from calliope.config import settings
from calliope.db import get_db, migrate_db
ROOT = Path(__file__).resolve().parents[2] / "example_ComfyUI_workflows"
API = {"1": {"class_type": "SaveImage", "inputs": {"filename_prefix": "test"}}}
async def test_all_sources_and_repeat_after_restart(tmp_path):
db = tmp_path / "library.db"
await migrate_db(db)
conn = get_db(db)
conn.execute(
"INSERT INTO workflows(name,kind,workflow_json) VALUES ('user','image',?)",
(json.dumps(API),),
)
conn.commit()
before = dict(conn.execute("SELECT * FROM workflows WHERE id=1").fetchone())
report = import_library(conn, ROOT, source_commit="fixture")
assert report["total"] == 156
assert report["states"] == {"needs_conversion": 145, "pending_check": 10}
assert conn.execute("SELECT count(*) FROM workflows WHERE is_enabled=0").fetchone()[0] == 155
assert dict(conn.execute("SELECT * FROM workflows WHERE id=1").fetchone()) == before
for row in conn.execute("SELECT * FROM workflows WHERE source_repo_path IS NOT NULL"):
doc = json.loads(row["doc_json"])
assert doc["source_nodes"]
assert doc["status"] == {"imported": True, "doc_done": False, "exec_verified": False}
assert json.loads(row["raw_source_json"]) == json.loads(
(ROOT.parent / row["source_repo_path"]).read_text()
)
conn.close()
await migrate_db(db)
conn = get_db(db)
second = import_library(conn, ROOT, source_commit="fixture")
assert second["counts"] == {"skipped": 155, "user_excluded": 1}
assert conn.execute("SELECT count(*) FROM workflows").fetchone()[0] == 156
conn.close()
async def test_update_user_conflict_and_rollback(tmp_path):
root = tmp_path / "sources"
root.mkdir()
source = root / "a.json"
source.write_text(json.dumps(API))
db = tmp_path / "local.db"
await migrate_db(db)
conn = get_db(db)
first = import_library(conn, root, source_commit="first")
old = dict(conn.execute("SELECT * FROM workflows").fetchone())
source.write_text(json.dumps({"2": {"class_type": "SaveAudio", "inputs": {}}}))
second = import_library(conn, root, source_commit="second")
assert second["counts"] == {"updated": 1}
assert conn.execute("SELECT kind FROM workflows").fetchone()[0] == "audio"
assert rollback_batch(conn, second["batch_id"])["files"][0]["result"] == "restored"
assert dict(conn.execute("SELECT * FROM workflows").fetchone()) == old
conn.execute("UPDATE workflows SET description='用户版' WHERE id=?", (old["id"],))
conn.commit()
assert import_library(conn, root, source_commit="third")["counts"] == {"conflict": 1}
assert rollback_batch(conn, first["batch_id"])["files"][0]["result"] == "conflict"
assert conn.execute("SELECT description FROM workflows").fetchone()[0] == "用户版"
conn.close()
async def test_rollback_new_rows_preserves_references(tmp_path):
await migrate_db(tmp_path / "db")
conn = get_db(tmp_path / "db")
root = tmp_path / "sources"
root.mkdir()
(root / "a.json").write_text(json.dumps(API))
report = import_library(conn, root, source_commit="first")
assert rollback_batch(conn, report["batch_id"])["files"][0]["result"] == "disabled"
assert conn.execute("SELECT import_state FROM workflows").fetchone()[0] == "rolled_back"
assert rollback_batch(conn, report["batch_id"])["files"] == []
assert import_library(conn, root, source_commit="first")["counts"] == {"updated": 1}
conn.close()
def test_legacy_constraint_migration_preserves_fk_and_indexes():
conn = sqlite3.connect(":memory:")
conn.execute("PRAGMA foreign_keys=ON")
conn.executescript("""
CREATE TABLE workflows(id INTEGER PRIMARY KEY, name TEXT,
kind TEXT CHECK(kind IN ('image', 'video')), workflow_json TEXT);
CREATE INDEX wf_name ON workflows(name);
CREATE TABLE jobs(id INTEGER PRIMARY KEY, workflow_id INTEGER REFERENCES workflows(id));
INSERT INTO workflows VALUES (9,'existing','image','{}');
INSERT INTO jobs VALUES(1,9);
""")
migrate_library(conn)
migrate_library(conn)
assert conn.execute("SELECT name FROM workflows WHERE id=9").fetchone()[0] == "existing"
assert conn.execute("SELECT workflow_id FROM jobs").fetchone()[0] == 9
assert conn.execute("PRAGMA foreign_key_check").fetchall() == []
assert conn.execute("PRAGMA foreign_keys").fetchone()[0] == 1
assert conn.execute("SELECT name FROM sqlite_master WHERE name='wf_name'").fetchone()
conn.execute("INSERT INTO workflows(id,kind) VALUES(10,'audio')")
with pytest.raises(sqlite3.IntegrityError):
conn.execute("DELETE FROM workflows WHERE id=9")
def test_ui_conversion_golden_and_ambiguous_controls():
info = {
"Scalar": {
"input": {"required": {"text": ["STRING", {}]}},
"input_order": {"required": ["text"]},
"output": ["STRING"],
},
"Sink": {
"input": {"required": {"value": ["STRING", {"forceInput": True}]}},
"input_order": {"required": ["value"]},
"output": [],
},
}
ui = {
"nodes": [
{"id": 1, "type": "Scalar", "widgets_values": {"text": "hello"}},
{"id": 2, "type": "Sink", "inputs": [{"name": "value", "link": 7}]},
],
"links": [[7, 1, 0, 2, 0, "STRING"]],
}
result = convert(ui, info)
assert result.issues == []
assert result.prompt == {
"1": {"class_type": "Scalar", "inputs": {"text": "hello"}, "_meta": {"title": "Scalar"}},
"2": {"class_type": "Sink", "inputs": {"value": ["1", 0]}, "_meta": {"title": "Sink"}},
}
ui["nodes"][0]["widgets_values"] = ["hello", "randomize"]
assert convert(ui, info).prompt is None
assert any(i["code"] == "widget_layout_unverified" for i in convert(ui, info).issues)
ui["nodes"][0]["mode"] = 4
assert any(i["code"] == "mode_requires_export" for i in convert(ui, info).issues)
assert convert(ui).prompt is None
def test_snapshot_failure_is_not_conversion_evidence(tmp_path):
path = tmp_path / "snapshot.json"
path.write_text(
json.dumps(
{
"source_url": "http://localhost/object_info",
"captured_at": "now",
"status": "unavailable",
}
)
)
with pytest.raises(ValueError):
load_snapshot(path)
def test_audio_and_subtitle_harvest_only_mapped_nodes():
client = ComfyUIClient("http://unused")
history = {
"outputs": {
"1": {"audio": [{"filename": "speech.flac"}]},
"2": {"files": [{"filename": "字幕.srt"}], "text": ["not a file"]},
"3": {"audio": [{"filename": "hidden.wav"}]},
}
}
outputs = client.extract_outputs(history, {"1": "audio", "2": "file"})
assert [o["media_kind"] for o in outputs] == ["audio", "file"]
assert auto_output_map({"1": {"class_type": "SaveAudio", "inputs": {}}})[0]["kind"] == "audio"
assert client.extract_outputs({"outputs": {"1": {"audio": ["inline text", {}]}}}) == []
def test_catalogue_routes_cannot_enable_or_execute_placeholder(client, tmp_path):
root = tmp_path / "sources"
root.mkdir()
(root / "ui.json").write_text(json.dumps({"nodes": [{"id": 1, "type": "Missing"}]}))
conn = get_db(settings.db_path)
report = import_library(conn, root, source_commit="fixture")
wid = report["files"][0]["workflow_id"]
conn.close()
body = client.get(f"/api/workflows/{wid}").json()
assert body["doc_json"]["draft"] is True
assert body["import_issues"]
assert "raw_source_json" not in body
assert (
client.patch(
f"/api/workflows/{wid}", json={"usage": "utility", "is_enabled": True}
).status_code
== 400
)
assert (
client.patch(f"/api/workflows/{wid}", json={"usage": "utility"}).json()["is_enabled"]
is False
)
assert client.post(f"/api/workflows/{wid}/reanalyze").json()["is_enabled"] is False
assert client.post(f"/api/workflows/{wid}/check", json={}).status_code == 400
settings.dry_run = False
try:
assert (
client.post(f"/api/workflows/{wid}/test", json={"input_values": {}}).status_code == 400
)
finally:
settings.dry_run = True
@pytest.mark.parametrize(
"kind,key,filename,usage,ct",
[
("audio", "audio", "speech.flac", "text2speech", "SaveAudio"),
("file", "files", "subtitle.srt", "speech2text", "CustomSubtitleSaver"),
],
)
def test_audio_file_queue_download(client, fake_comfy, kind, key, filename, usage, ct):
from tests.test_studio_generation import PNG_1PX, _real_run
from tests.test_workflow_test import _wait_terminal
with _real_run(client, fake_comfy):
fake_comfy.forced_output_node = "9"
fake_comfy.outputs_key = key
fake_comfy.out_name = filename
workflow = {"9": {"class_type": ct, "inputs": {"filename_prefix": "test"}}}
response = client.post(
"/api/workflows",
json={
"name": filename,
"kind": kind,
"usage": usage,
"workflow_json": workflow,
"output_map": [{"nodeId": "9", "kind": kind}],
},
)
assert response.status_code == 200, response.text
wid = response.json()["id"]
response = client.post(f"/api/workflows/{wid}/test", json={"input_values": {}})
assert response.status_code == 200, response.text
job = _wait_terminal(client, response.json()["job"]["id"])
assert job["status"] == "done", job.get("error")
output = Path(job["output_paths"][0])
assert output.name == filename and output.read_bytes() == PNG_1PX
# This fixture verifies transport and persistence, not a real audio codec/subtitle.
assert any(path.startswith("/view?") for path in fake_comfy.requests)
def test_dedupe_preserves_separate_source_paths(client, tmp_path):
root = tmp_path / "sources"
for name in ("a", "b"):
(root / name).mkdir(parents=True)
(root / name / "same.json").write_text(json.dumps(API))
conn = get_db(settings.db_path)
import_library(conn, root, source_commit="fixture")
conn.close()
assert client.post("/api/workflows/dedupe").json()["removed"] == 0
assert len(client.get("/api/workflows").json()) == 2
def test_rebuild_preserves_autoincrement_watermark():
conn = sqlite3.connect(":memory:")
conn.executescript("""
CREATE TABLE workflows(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,
kind TEXT CHECK(kind IN ('image', 'video')), workflow_json TEXT);
INSERT INTO workflows(id,kind) VALUES(100,'image');
DELETE FROM workflows;
""")
migrate_library(conn)
assert conn.execute("INSERT INTO workflows(kind) VALUES('audio')").lastrowid == 101
def test_document_dependencies_do_not_treat_notes_or_editor_urls_as_models():
from calliope.comfyui.library import build_document
source = {
"nodes": [
{"id": 1, "type": "Loader", "widgets_values": ["actual.safetensors"]},
{"id": 2, "type": "Note", "widgets_values": ["example.safetensors"]},
],
"properties": {"url": "https://example.com/download.safetensors"},
}
doc = build_document("example/test.json", source, None, None, [])
assert doc["dependencies"]["models"] == ["actual.safetensors"]
assert doc["source_notes"][0]["content"] == ["example.safetensors"]