Files
ComfyUI-H3-Continuum-Tiled/tests/test_v39_stability_r2.py
T

226 lines
9.9 KiB
Python

from __future__ import annotations
import copy
import functools
import hashlib
import json
from pathlib import Path
import shutil
from types import SimpleNamespace
import pytest
from ComfyUI_H3_Continuum_Join import run_storage as storage
from ComfyUI_H3_Continuum_Join.graph_contract import build_upstream_graph_contract
from ComfyUI_H3_Continuum_Join.v3.review_control import (
GENERATION_MODE_REVIEW, REVIEW_ACTION_CONTINUE, REVIEW_ACTION_REGENERATE_CURRENT,
ReviewControlError,
)
from . import test_v31_run_storage as signatures
from . import test_v38_review_run_storage as review
def closure(gain):
def sample(x=None, **kwargs):
return x * gain
return sample
@pytest.mark.parametrize("option", [
"sampler_cfg_function", "sampler_pre_cfg_function", "sampler_post_cfg_function",
"model_function_wrapper", "denoise_mask_function",
])
def test_model_hook_changes_are_observed(option):
model = signatures._Model()
model.model_options[option] = closure(1)
before, safe = storage._model_signature(model, "base")
model.model_options[option] = closure(2)
after, after_safe = storage._model_signature(model, "base")
assert safe and after_safe
assert before != after
def test_cfg1_and_internal_join_context():
model = signatures._Model()
before, safe = storage._model_signature(model, "base")
model.model_options["disable_cfg1_optimization"] = True
after, safe_after = storage._model_signature(model, "base")
assert safe and safe_after and before != after
model.model_options["transformer_options"] = {"h3_continuum_join_context": object()}
join, safe_join = storage._model_signature(model, "base")
model.model_options["transformer_options"] = {}
clean, safe_clean = storage._model_signature(model, "base")
assert safe_join and safe_clean and join == clean
def test_sampler_closure_only_changes_identity_with_graph_unchanged():
graph, graph_safe, _ = build_upstream_graph_contract(
signatures._prompt_graph(), "42", require_video_vae=True,
)
model, clip, vae = signatures._Model(), signatures._Clip(), signatures._VideoVAE()
sampler = SimpleNamespace(sampler_function=closure(1), extra_options={}, inpaint_options={})
kwargs = dict(model=model, clip=clip, video_vae=vae, sampler=sampler,
upstream_graph_contract=graph, upstream_graph_safe=graph_safe)
before, safe, _ = signatures._sampling_contract(**kwargs)
sampler.sampler_function = closure(2)
after, after_safe, _ = signatures._sampling_contract(**kwargs)
assert safe and after_safe
assert before["global"]["upstream_graph"] == after["global"]["upstream_graph"]
assert storage.revision_identity(before) != storage.revision_identity(after)
same, same_safe, _ = signatures._sampling_contract(**kwargs)
assert same_safe and same == after
def test_sampler_graph_only_changes_identity():
graph = signatures._prompt_graph()
before, safe, _ = build_upstream_graph_contract(graph, "42", require_video_vae=True)
graph["40"]["inputs"]["sampler_name"] = "heun"
after, after_safe, _ = build_upstream_graph_contract(graph, "42", require_video_vae=True)
assert safe and after_safe and before != after
assert before["version"] == after["version"] == 4
assert before["routes"]["model"] == after["routes"]["model"]
def test_partial_and_bound_method_state_are_observed():
class Bound:
def __init__(self, gain):
self.gain = gain
def sample(self, value):
return value * self.gain
first, safe = storage._observe(functools.partial(Bound(1).sample, 2))
second, safe_second = storage._observe(functools.partial(Bound(3).sample, 2))
assert safe and safe_second and first != second
@pytest.mark.parametrize("location", ["wrappers", "patches", "model_options"])
def test_opaque_state_disables_reuse_without_preventing_contract(location):
class Opaque:
__slots__ = ("gain",)
def __init__(self):
self.gain = 1
def __call__(self, *args):
return self.gain
model = signatures._Model()
getattr(model, location)["external"] = Opaque()
contract, safe, reasons = signatures._sampling_contract(model=model)
assert contract["global"]["sampling_contract_version"] == 6
assert not safe and reasons
def test_empty_callable_attributes_are_not_complete():
class Opaque:
def __call__(self):
return 1
_, safe = storage._observe(Opaque())
assert not safe
def test_observation_bounds_preserve_ordinary_lora_keys_without_weight_traversal():
_, keys_safe = storage._observe({f"weight.{index}" for index in range(500)})
_, oversized_safe = storage._observe(list(range(4097)))
module = signatures._Model().model.diffusion_model
descriptor, module_safe = storage._observe(module)
assert keys_safe and not oversized_safe and not module_safe
assert descriptor["module_state_unobserved"]
def test_signature_failure_is_diagnostic_not_a_generation_stop():
model = signatures._Model()
model.model_dtype = lambda: (_ for _ in ()).throw(RuntimeError("custom dtype"))
contract, safe, reasons = signatures._sampling_contract(model=model)
assert contract and not safe and reasons
def test_core_euler_sampler_has_an_observable_runtime_signature(require_comfy_core):
from comfy.samplers import sampler_object
_, safe = storage._sampler_signature(sampler_object("euler"))
assert safe
def reader(tmp_path, contract):
controller = review._controller(tmp_path, contract)
controller.configure_review(generation_mode=GENERATION_MODE_REVIEW,
review_action=REVIEW_ACTION_CONTINUE)
return controller
@pytest.mark.parametrize("entry_point", ["head", "review", "import", "compatible", "take"])
def test_safe_false_never_adopts_a_prefix(tmp_path, entry_point):
contract = review._contract(chunks=3)
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
updated_utc="2026-10-04T00:00:00+00:00")
controller = reader(tmp_path, contract)
original = (source._manifest_path().read_bytes(), (source.run_root / "project.json").read_bytes())
if entry_point == "head":
assert controller.find_latest_review_head(contract, resume_safe=False) is None
elif entry_point == "review":
assert not controller._load_validated_review_prefix(contract, resume_safe=False).entries
elif entry_point == "import":
assert controller._find_plan_import(contract, resume_safe=False) is None
elif entry_point == "compatible":
assert controller._compatible_plan_prefix(source.manifest, contract, resume_safe=False) == ([], [])
else:
controller.take_group = 2
controller.take_revision_id = review._project(source)["canonical_head_revision_id"]
with pytest.raises(storage.RunStorageError, match="unobservable"):
controller._validated_take_selection(contract, resume_safe=False)
assert original == (source._manifest_path().read_bytes(), (source.run_root / "project.json").read_bytes())
def test_safe_false_retry_preserves_existing_take(tmp_path):
contract = review._contract(chunks=3)
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
updated_utc="2026-10-04T00:00:00+00:00")
controller = reader(tmp_path, contract)
controller.review_action = REVIEW_ACTION_REGENERATE_CURRENT
before = source._manifest_path().read_bytes()
with pytest.raises(ReviewControlError, match="could not be matched"):
controller._load_validated_review_prefix(contract, resume_safe=False)
assert source._manifest_path().read_bytes() == before
def test_identical_v6_review_and_take_still_reuse(tmp_path):
contract = review._contract(chunks=3)
source = review._persist(tmp_path, contract, prefix=2, review_unit=(2, 2),
updated_utc="2026-10-04T00:00:00+00:00")
controller = reader(tmp_path, contract)
assert len(controller._load_validated_review_prefix(contract, resume_safe=True).entries) == 2
controller.take_group = 2
controller.take_revision_id = review._project(source)["canonical_head_revision_id"]
assert len(controller._validated_take_selection(contract)["entries"]) == 2
def fixture_hashes(root):
return {str(file.relative_to(root)): hashlib.sha256(file.read_bytes()).hexdigest()
for file in root.rglob("*") if file.is_file()}
def test_actual_old_code_v5_fixture_readable_and_immutable(tmp_path):
fixture = Path(__file__).parent / "fixtures" / "v39_sampling_v5"
before = fixture_hashes(fixture)
run = tmp_path / "run"
shutil.copytree(fixture, run)
controller = storage.RunStorageController("legacy-read")
controller.run_root = run
controller.revisions_root = run / "revisions"
manifests, catalog, chains = controller._provenance_catalog()
assert len(manifests) == 1 and len(catalog) == 2 and len(chains) == 1
manifest = next(iter(manifests.values()))
assert manifest["sampling_contract_version"] == 5
assert manifest["contract"]["global"]["sampling_contract_version"] == 5
storage._manifest_sampling_identity(manifest)
head = controller._validated_review_head(manifest, for_reuse=False)
assert head["validated_prefix_count"] == 2
assert len(head["entries"]) == 2
contract = review._contract(chunks=manifest["contract"]["chunk_count"])
controller.prompts = [""] * contract["chunk_count"]
assert controller.find_latest_review_head(contract) is None
assert controller._compatible_plan_prefix(manifest, contract) == ([], [])
assert controller._find_plan_import(contract) is None
controller.take_group = 2
controller.take_revision_id = head["manifest"]["branch_provenance"]["active_chain"][-1]
with pytest.raises(storage.RunStorageError, match="read-only"):
controller._validated_take_selection(contract, source_lineage=manifest["contract"]["nonce_lineage_sha256"])
assert fixture_hashes(fixture) == before
assert fixture_hashes(run) == before