Files
DumasNodes/tests/test_loaders.py
T
chris.dumas 70d0672ee3 Squashed 'vendor/dumas_minimax_h3_refmod/' content from commit 517e8c4
git-subtree-dir: vendor/dumas_minimax_h3_refmod
git-subtree-split: 517e8c419a8584fbf69fceb487bc39d83e6a6ec8
2026-10-20 13:43:44 +00:00

230 lines
11 KiB
Python

"""Loader regressions using real safetensors and ComfyUI's queue validator.
Run with ComfyUI's Python: python tests/test_loaders.py
No models or server are started; all mod files live in temporary folders.
"""
import asyncio
import contextlib
import importlib
import io
import json
import os
from pathlib import Path
import sys
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT.parents[1]))
from comfy.cli_args import args
args.cpu = True
import folder_paths
import torch
from safetensors.torch import save_file
with tempfile.TemporaryDirectory() as import_dir:
with patch.object(folder_paths, "models_dir", import_dir):
N = importlib.import_module(f"custom_nodes.{ROOT.name}.nodes")
import execution
import nodes as comfy_nodes
class UpstreamString:
RETURN_TYPES = ("STRING",)
FUNCTION = "run"
@classmethod
def INPUT_TYPES(cls):
return {"required": {"text": ("STRING",)}}
def run(self, text):
raise AssertionError("Queue validation must not execute upstream nodes")
class LoaderTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name) / "refmods"
self.legacy = Path(self.temp.name) / "mods"
self.root.mkdir()
self.legacy.mkdir()
search = patch.object(N, "_mod_search_dirs", return_value=[str(self.root), str(self.legacy)])
search.start()
self.addCleanup(search.stop)
N._MOD_CACHE.clear()
N._MOD_LIST_CACHE_KEY = N._MOD_LIST_CACHE_VAL = None
output = contextlib.redirect_stdout(io.StringIO())
output.__enter__()
self.addCleanup(output.__exit__, None, None, None)
def save_mod(self, name, kind="image", root=None, value=1.0, metadata=None):
path = (root or self.root) / name
path.parent.mkdir(parents=True, exist_ok=True)
mod = N.H3RefMod(name=path.name, kind=kind,
latent=torch.full((1, 24, 1, 4, 4), value),
latent_h=4, latent_w=4)
if metadata is None:
mod.save(str(path))
else:
save_file({"latent": mod.latent}, str(path) + ".safetensors",
metadata={"refmod_meta": json.dumps(metadata)})
return path
def test_empty_names_validate_and_execute_in_every_slot(self):
for cls in (N.MiniMaxH3RefModsLoader, N.MiniMaxH3RefModsAxis):
for field in cls.INPUT_TYPES()["required"]:
if not field.startswith("mod_"):
continue
for empty in (None, "", "None", "(none)"):
with self.subTest(node=cls.__name__, field=field, empty=empty):
inputs = {field: empty}
if "_a_" in field or "_b_" in field:
inputs["value_" + field.rsplit("_", 1)[1]] = -1 if "_a_" in field else 1
self.assertIs(cls.VALIDATE_INPUTS(**inputs), True)
self.assertEqual(cls().load(**inputs), ([], ""))
def test_recursive_listing_filters_metadata_and_presets(self):
self.save_mod("root")
self.save_mod("celebs/person", kind="video")
self.save_mod("oc/deep/person", root=self.legacy)
self.save_mod("celebs/audio", metadata={"kind": "other"})
self.save_mod("celebs/bad_json_type", metadata=["image"])
self.save_mod("graph_presets/hidden")
self.save_mod("oc/graph_presets/hidden")
(self.root / "curve.png").touch()
(self.root / "junk.safetensors").write_bytes(b"invalid")
expected = ["celebs/person", "oc/deep/person", "root"]
self.assertEqual(N._list_mod_names(), expected)
for cls in (N.MiniMaxH3RefModsLoader, N.MiniMaxH3RefModsAxis):
for field, schema in cls.INPUT_TYPES()["required"].items():
if field.startswith("mod_"):
self.assertEqual(schema[0], ["(none)"] + expected)
def test_listing_cache_reuses_metadata_reads(self):
self.save_mod("deep/a")
with patch.object(N, "read_refmod_meta", wraps=N.read_refmod_meta) as read:
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.assertEqual(read.call_count, 1)
def test_nested_add_rename_delete_refresh_listing(self):
self.assertEqual(N._list_mod_names(), [])
path = self.save_mod("new/deep/a")
self.assertEqual(N._list_mod_names(), ["new/deep/a"])
file = Path(str(path) + ".safetensors")
renamed = file.with_name("b.safetensors")
file.rename(renamed)
self.assertEqual(N._list_mod_names(), ["new/deep/b"])
renamed.unlink()
self.assertEqual(N._list_mod_names(), [])
def test_subsecond_metadata_change_refreshes_listing(self):
path = self.save_mod("deep/a", metadata={"kind": "image"})
file = Path(str(path) + ".safetensors")
stamp = 1_700_000_000_100_000_000
os.utime(file, ns=(stamp, stamp))
self.assertEqual(N._list_mod_names(), ["deep/a"])
self.save_mod("deep/a", metadata={"kind": "other"})
os.utime(file, ns=(stamp + 1_000_000, stamp + 1_000_000))
self.assertEqual(N._list_mod_names(), [])
def test_legacy_sidecar_add_change_delete_refresh_listing(self):
path = self.root / "deep" / "legacy"
path.parent.mkdir()
save_file({"latent": torch.zeros(1, 24, 1, 4, 4)}, str(path) + ".safetensors")
self.assertEqual(N._list_mod_names(), [])
sidecar = Path(str(path) + ".json")
sidecar.write_text('{"kind": "image"}')
self.assertEqual(N._list_mod_names(), ["deep/legacy"])
self.assertEqual(N._load_mod("deep/legacy").kind, "image")
sidecar.write_text('{"kind": "unsupported"}')
self.assertEqual(N._list_mod_names(), [])
sidecar.unlink()
self.assertEqual(N._list_mod_names(), [])
def test_search_root_identity_and_precedence(self):
self.save_mod("a", value=1)
self.save_mod("a", root=self.legacy, value=2)
self.assertEqual(N._list_mod_names(), ["a"])
self.assertEqual(N._load_mod("a").latent.flatten()[0].item(), 1)
with patch.object(N, "_mod_search_dirs", return_value=[str(self.legacy)]):
self.assertEqual(N._load_mod("a").latent.flatten()[0].item(), 2)
self.save_mod("a", metadata={"kind": "other"})
self.assertEqual(N._list_mod_names(), [])
def test_nested_runtime_both_loaders_and_windows_separators(self):
self.save_mod("celebs/person", value=3)
self.assertIs(N.MiniMaxH3RefModsLoader.VALIDATE_INPUTS(mod_1="celebs\\person"), True)
bundle, _ = N.MiniMaxH3RefModsLoader().load(mod_1="celebs\\person", strength_1=0.6, copies_1=2)
self.assertEqual(len(bundle), 2)
self.assertEqual(bundle[0][1], 0.6)
self.assertEqual(bundle[0][0].latent.flatten()[0].item(), 3)
for side, value in (("a", -0.4), ("b", 0.4)):
bundle, _ = N.MiniMaxH3RefModsAxis().load(**{f"mod_{side}_1": "celebs/person", "value_1": value})
self.assertEqual(bundle[0][1], 0.4)
self.assertIs(bundle[0][0], N._load_mod("celebs\\person"))
def test_same_metadata_name_config_does_not_poison_root_cache(self):
self.save_mod("person", value=1)
nested_path = self.save_mod("celebs/person", value=2)
root_mod = N._load_mod("person")
nested_mod = N._load_mod("celebs/person")
N.MiniMaxH3RefModConfig().fix([(nested_mod, 1.0)], retention=0.4)
self.assertIs(N._load_mod("person"), root_mod)
self.assertEqual(root_mod.config, {})
self.assertEqual(N.H3RefMod.load(str(nested_path)).config["retention"], 0.4)
def test_fixed_missing_names_rejected_and_linked_missing_fail_at_load(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "mod_1"),
(N.MiniMaxH3RefModsAxis, "mod_a_1"),
(N.MiniMaxH3RefModsAxis, "mod_b_1")):
self.assertIn("not found", cls.VALIDATE_INPUTS(**{field: "missing"}))
self.assertIs(cls.VALIDATE_INPUTS(input_types={field: "STRING"}, **{field: None}), True)
with self.assertRaisesRegex(FileNotFoundError, "missing"):
N.MiniMaxH3RefModsLoader().load(mod_1="missing")
def test_path_boundary_is_checked_at_execution(self):
for name in ("../outside", "a/../../outside", "/absolute", "C:/absolute", "C:relative",
"\\\\server\\share\\mod", "graph_presets/a"):
with self.subTest(name=name), self.assertRaises(ValueError):
N._load_mod(name)
def test_actual_comfy_queue_with_unexecuted_upstream(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "mod_1"),
(N.MiniMaxH3RefModsAxis, "mod_a_1"),
(N.MiniMaxH3RefModsAxis, "mod_b_1")):
inputs = {}
for name, (kind, options) in cls.INPUT_TYPES()["required"].items():
inputs[name] = kind[0] if isinstance(kind, list) else options["default"]
inputs[field] = ["source", 0]
prompt = {"source": {"class_type": "TestRefModString", "inputs": {"text": "future/person"}},
"loader": {"class_type": "TestRefModLoader", "inputs": inputs}}
with patch.dict(comfy_nodes.NODE_CLASS_MAPPINGS, TestRefModString=UpstreamString, TestRefModLoader=cls):
for output_type in ("STRING", "COMBO", ["future/person"]):
with self.subTest(node=cls.__name__, field=field, output_type=output_type):
with patch.object(UpstreamString, "RETURN_TYPES", (output_type,)):
result = asyncio.run(execution.validate_inputs("test-refmods", prompt, "loader", {}))
self.assertTrue(result[0], result)
with patch.object(UpstreamString, "RETURN_TYPES", ("IMAGE",)):
result = asyncio.run(execution.validate_inputs("test-refmods", prompt, "loader", {}))
self.assertFalse(result[0], result)
def test_connected_non_mod_inputs_keep_type_checks(self):
for cls, field in ((N.MiniMaxH3RefModsLoader, "strength_1"),
(N.MiniMaxH3RefModsLoader, "copies_1"),
(N.MiniMaxH3RefModsLoader, "show_info"),
(N.MiniMaxH3RefModsAxis, "value_1")):
with self.subTest(field=field):
self.assertIn("expected", cls.VALIDATE_INPUTS(input_types={field: "IMAGE"}))
if __name__ == "__main__":
unittest.main(verbosity=2)