Files
aigc-home/calliope-backend/tests/test_wanplus_fixed_document.py
T
2026-11-01 19:07:30 +08:00

243 lines
10 KiB
Python

"Exact graph binding, all saved positions, dual scopes and closed eligibility."
import copy
import hashlib
import json
import runpy
import sys
from pathlib import Path
import pytest
from calliope.comfyui.fixed_document import DEFINITIONS, canonical
from calliope.comfyui.library import build_document
from calliope.comfyui.source_reviews import review_for
REPO = Path(__file__).resolve().parents[2]
OUT = REPO / ("docs/hel-892/wanplus-document-evidence")
PATH = "example_ComfyUI_workflows/6-动作迁移/Wan2.1_Scail-2_动作迁移_WanAnimatePlus_v4.2.json"
RAW = (REPO / PATH).read_bytes()
SOURCE = json.loads(RAW)
REVIEW = review_for(PATH, hashlib.sha1(RAW).hexdigest())
BLOCK = REVIEW["fixed_version_document"]
def pointer(obj, p):
for x in p.strip("/").split("/"):
obj = obj[int(x)] if isinstance(obj, list) else obj[x]
return obj
def doc(s=SOURCE, r=REVIEW):
return build_document(PATH, s, None, None, [], r)
@pytest.mark.parametrize("f", BLOCK["fields"], ids=lambda f: f["node_id"] + "." + f["field"])
def test_each_saved_position_and_citation(f):
assert canonical(pointer(SOURCE, f["pointer"])) == canonical(f["value"])
assert type(pointer(SOURCE, f["pointer"])).__name__ == f["json_type"]
assert f["named_state"] == "missing" and "named_pointer" not in f and "named_value" not in f
assert all(
f[k] for k in ["label", "unit", "limits", "schema_default", "effect", "execution_note"]
)
if f["input_pointer"].startswith("/"):
assert pointer(SOURCE, f["input_pointer"])["name"] == f["input_name"]
for i in f["evidence"]:
e = BLOCK["sources"][i]
raw = (OUT / e["local_file"]).read_bytes()
assert hashlib.sha256(raw).hexdigest() == e["sha256"]
if raw:
assert 1 <= e["lines"][0] <= e["lines"][1] <= len(raw.decode().splitlines())
else:
assert e["lines"] == [0, 0] and "零字节" in e["claim"]
@pytest.mark.parametrize("f", BLOCK["fields"], ids=lambda f: f["node_id"] + "." + f["field"])
@pytest.mark.parametrize("variant", ["source", "text"])
def test_caller_rehash_cannot_expand_trust(f, variant):
s, r = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
if variant == "text":
r["fixed_version_document"]["fields"][BLOCK["fields"].index(f)]["effect"] = "forged"
else:
selected_pointer = f["pointer"]
p, _, key = selected_pointer.rpartition("/")
parent = pointer(s, p)
parent[int(key) if isinstance(parent, list) else key] = "forged"
r["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(canonical(s)).hexdigest()
assert not doc(s, r)["fixed_version"]["matched"]
@pytest.mark.parametrize("key", ["extra", "links", "id", "groups", "version", "definitions"])
def test_whole_graph_mutations_fail_closed(key):
source, review = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
source[key] = {"subgraphs": []} if key == "definitions" else "forged"
review["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(
canonical(source)
).hexdigest()
assert not doc(source, review)["fixed_version"]["matched"]
@pytest.mark.parametrize("key", ["mode", "properties", "inputs", "outputs"])
@pytest.mark.parametrize("index", [0, 1, 4])
def test_node_identity_and_state_fail_closed(key, index):
source, review = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
source["nodes"][index][key] = "forged"
review["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(
canonical(source)
).hexdigest()
assert not doc(source, review)["fixed_version"]["matched"]
def test_path_and_source_binding_cannot_be_extended():
from calliope.comfyui.fixed_document import fixed_document_for
assert fixed_document_for(PATH + "forged", SOURCE, REVIEW) is None
review = copy.deepcopy(REVIEW)
review["source_sha"] = "forged"
assert not doc(SOURCE, review)["fixed_version"]["matched"]
@pytest.mark.parametrize("suffix", [b"\n", b" ", b"\t"])
def test_original_byte_identity_rejects_equivalent_json(suffix):
altered = RAW + suffix
assert json.loads(altered) == SOURCE
assert review_for(PATH, hashlib.sha1(altered).hexdigest()) is None
@pytest.mark.parametrize("key", ["user_overview", "source_sha256", "sources", "flow", "counts"])
def test_editorial_or_citation_rehash_cannot_replace_code_owned_pin(key):
source, review = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
review["fixed_version_document"][key] = "forged"
review["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(
canonical(source)
).hexdigest()
assert not doc(source, review)["fixed_version"]["matched"]
@pytest.mark.parametrize("key", ["properties", "inputs", "outputs", "mode"])
@pytest.mark.parametrize(
"node_pointer",
[
f"{pre}/nodes/{i}"
for pre, g in [("", SOURCE)]
+ [
(f"/definitions/subgraphs/{j}", s)
for j, s in enumerate(SOURCE["definitions"]["subgraphs"])
]
for i, _ in enumerate(g["nodes"])
],
)
def test_control_identity_and_state_forgery_fail_closed(node_pointer, key):
s, r = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
pointer(s, node_pointer)[key] = "forged"
r["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(canonical(s)).hexdigest()
assert not doc(s, r)["fixed_version"]["matched"]
def test_exact_build_and_qualification():
assert canonical(
runpy.run_path(str(OUT.parent / "wanplus-document-evidence/build_definition.py"))["build"]()
) == canonical(BLOCK)
assert PATH in DEFINITIONS and len(DEFINITIONS) >= 141 and doc()["fixed_version"]["matched"]
assert BLOCK["counts"]["saved_fields"] == 339 and len(BLOCK["comments"]) == 6
assert len(BLOCK["boundaries"]) == 1 and len(BLOCK["zero_saved_nodes"]) == 15
assert not doc()["status"]["doc_done"] and not doc()["status"]["exec_verified"]
sys.path.insert(0, str(OUT.parent / "wanplus-document-evidence"))
try:
runpy.run_path(str(OUT.parent / "wanplus-document-evidence/verify_sources.py"))["main"]()
finally:
sys.path.remove(str(OUT.parent / "wanplus-document-evidence"))
def test_raw_source_version_mismatch_is_fail_closed():
source, review = copy.deepcopy(SOURCE), copy.deepcopy(REVIEW)
source["nodes"][1]["properties"]["ver"] = "other-plugin-version"
review["fixed_version_document"]["canonical_sha256"] = hashlib.sha256(
canonical(source)
).hexdigest()
assert not doc(source, review)["fixed_version"]["matched"]
def test_old_reviews_and_qualification_are_unchanged():
import subprocess
name = "calliope-backend/src/calliope/comfyui/source_reviews.json"
previous = json.loads(
subprocess.check_output(
["git", "show", "8cceb56c006b00a9dd9cf3dda2233a3ea740754d:" + name], cwd=REPO
)
)
current = json.loads((REPO / name).read_bytes())
for path, review in previous.items():
if path != PATH:
assert current[path] == review
else:
current_without = dict(current[path])
current_without.pop("fixed_version_document")
assert current_without == review
old = [r["fixed_version_document"] for r in previous.values() if "fixed_version_document" in r]
assert len(old) == 140 and sum(len(b["fields"]) for b in old) == 8822
def test_exact_classes_and_concrete_protocol_gaps():
assert len(BLOCK["node_bindings"]) == 135
assert sum(b["implementation_verified"] for b in BLOCK["node_bindings"]) == 53
assert {
b["node_id"] for b in BLOCK["node_bindings"] if b["source_id"].startswith("unresolved-")
} == {"37", "62", "67", "71", "597", "607", "69", "66", "614", "615"}
assert sum(b["source_id"] == "unknown-no-version" for b in BLOCK["node_bindings"]) == 71
assert sum(b["source_id"] == "subgraph-definition" for b in BLOCK["node_bindings"]) == 1
assert sum(f["json_type"] == "NoneType" for f in BLOCK["fields"]) == 2
assert sum(f["json_type"] == "dict" for f in BLOCK["fields"]) == 7
assert BLOCK["counts"]["root_saved_fields"] == 328
assert BLOCK["counts"]["internal_saved_fields"] == 11
assert BLOCK["boundaries"][0]["proxy_state"] == "missing"
assert BLOCK["boundaries"][0]["proxy_mappings"] == []
def test_empty_dict_and_mode4_are_preserved():
nodes = {n["id"]: n for n in SOURCE["nodes"]}
assert nodes[546]["widgets_values"] == {}
assert nodes[629]["widgets_values"] == [{}, {}]
assert nodes[607]["outputs"][1]["links"] is None
assert sum(n["mode"] == 4 for n in SOURCE["nodes"]) == 38
assert all(n["mode"] == 4 for n in SOURCE["definitions"]["subgraphs"][0]["nodes"])
assert "frontendVersion" not in SOURCE["extra"]
assert "proxyWidgets" not in nodes[663]["properties"]
@pytest.mark.parametrize("nid", ["119", "567", "621", "550"])
def test_h264_dynamic_fields_bind_their_own_version(nid):
fields = {f["field"]: f for f in BLOCK["fields"] if f["node_id"] == nid}
version = next(n for n in SOURCE["nodes"] if str(n["id"]) == nid)["properties"]["ver"]
for name in ["crf", "pix_fmt", "save_metadata", "trim_to_audio"]:
f = fields[name]
assert f["role"] == "schema_input" and "准确本版本H264动态格式控件" in f["limits"]
formats = [
BLOCK["sources"][i]
for i in f["evidence"]
if BLOCK["sources"][i]["file"] == "video_formats/h264-mp4.json"
]
assert len(formats) == 1 and formats[0]["commit"] == version
template = json.loads((OUT / formats[0]["local_file"]).read_bytes())
assert template["extension"] == "mp4" and "libx264" in template["main_pass"]
assert fields["crf"]["schema_default"] == "19"
assert fields["save_metadata"]["schema_default"] == "true"
assert fields["trim_to_audio"]["schema_default"] == "false"
@pytest.mark.parametrize(
"key", ["named_value", "named_pointer", "schema_default", "unit", "limits"]
)
def test_guessed_data_cannot_expand_trust(key):
r = copy.deepcopy(REVIEW)
r["fixed_version_document"]["fields"][0][key] = "forged"
assert not doc(SOURCE, r)["fixed_version"]["matched"]
@pytest.mark.parametrize("note", BLOCK["comments"], ids=lambda n: n["node_id"])
def test_complete_notes_are_preserved_and_pinned(note):
assert pointer(SOURCE, note["pointer"]) == note["text"]
r = copy.deepcopy(REVIEW)
r["fixed_version_document"]["comments"][BLOCK["comments"].index(note)]["text"] = "forged"
assert not doc(SOURCE, r)["fixed_version"]["matched"]