207 lines
7.5 KiB
Python
207 lines
7.5 KiB
Python
import importlib
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import types
|
|
import unittest
|
|
|
|
|
|
class FakeImage:
|
|
saved_paths = []
|
|
|
|
def save(self, path, *args, **kwargs):
|
|
self.saved_paths.append((path, args, kwargs))
|
|
os.makedirs(os.path.dirname(path), exist_ok=True)
|
|
open(path, "wb").close()
|
|
|
|
def convert(self, _mode):
|
|
return self
|
|
|
|
|
|
class FakeBatch:
|
|
shape = (1, 6, 8, 3)
|
|
|
|
def cpu(self):
|
|
return self
|
|
|
|
def numpy(self):
|
|
return self
|
|
|
|
def clip(self, _low, _high):
|
|
return self
|
|
|
|
def __mul__(self, _value):
|
|
return self
|
|
|
|
def astype(self, _dtype):
|
|
return self
|
|
|
|
def __getitem__(self, _index):
|
|
return self
|
|
|
|
|
|
class DumasImageNodeTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.temp_dir = tempfile.mkdtemp(prefix="dumas-image-node-")
|
|
fake_numpy = types.SimpleNamespace(clip=lambda array, _low, _high: array, uint8="uint8")
|
|
fake_pil_image = types.SimpleNamespace(fromarray=lambda _array: FakeImage())
|
|
fake_pil = types.SimpleNamespace(Image=fake_pil_image)
|
|
fake_folder_paths = types.SimpleNamespace(
|
|
get_temp_directory=lambda: cls.temp_dir,
|
|
get_output_directory=lambda: cls.temp_dir,
|
|
get_save_image_path=lambda prefix, _out, _width, _height: (cls.temp_dir, prefix, 1, "", prefix),
|
|
)
|
|
cls.saved = {name: sys.modules.get(name) for name in ("numpy", "PIL", "PIL.Image", "folder_paths")}
|
|
sys.modules["numpy"] = fake_numpy
|
|
sys.modules["PIL"] = fake_pil
|
|
sys.modules["PIL.Image"] = fake_pil_image
|
|
sys.modules["folder_paths"] = fake_folder_paths
|
|
cls.nodes = importlib.import_module("dumas_image_nodes")
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
for name, module in cls.saved.items():
|
|
if module is None:
|
|
sys.modules.pop(name, None)
|
|
else:
|
|
sys.modules[name] = module
|
|
|
|
def test_generic_image_nodes_are_registered(self):
|
|
self.assertEqual(
|
|
set(self.nodes.NODE_CLASS_MAPPINGS),
|
|
{"DumasImageCompare", "DumasSaveImage", "DumasLoadImagesFolder"},
|
|
)
|
|
|
|
def test_save_image_exposes_image_folder_and_filename_outputs(self):
|
|
node = self.nodes.DumasSaveImageNode
|
|
self.assertEqual(node.RETURN_NAMES, ("image", "folder", "filename"))
|
|
self.assertEqual(node.OUTPUT_IS_LIST, (False, False, True))
|
|
|
|
def test_compare_without_inputs_returns_empty_result(self):
|
|
result = self.nodes.DumasImageCompareNode().compare_images()
|
|
self.assertEqual(result["ui"]["images"], [])
|
|
self.assertIsNone(result["result"][0])
|
|
|
|
def test_compare_preview_names_are_unique(self):
|
|
first = self.nodes.DumasImageCompareNode().compare_images(FakeBatch())
|
|
second = self.nodes.DumasImageCompareNode().compare_images(FakeBatch())
|
|
self.assertNotEqual(
|
|
first["ui"]["images"][0]["filename"],
|
|
second["ui"]["images"][0]["filename"],
|
|
)
|
|
|
|
def test_compare_uses_second_tensor_without_boolean_coercion(self):
|
|
image1 = FakeBatch()
|
|
image2 = FakeBatch()
|
|
result = self.nodes.DumasImageCompareNode().compare_images(image1, image2)
|
|
self.assertIs(result["result"][0], image2)
|
|
|
|
def test_load_folder_node_has_expected_outputs(self):
|
|
self.assertEqual(
|
|
self.nodes.DumasLoadImagesFolderNode.RETURN_NAMES,
|
|
("image", "mask", "width", "height", "filename", "index", "total", "path"),
|
|
)
|
|
self.assertEqual(self.nodes.DumasLoadImagesFolderNode.OUTPUT_IS_LIST, (True,) * 8)
|
|
|
|
def test_folder_listing_includes_thumbnail_metadata(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = os.path.join(directory, "frame.png")
|
|
open(path, "wb").close()
|
|
files = self.nodes._list_folder_image_files(directory)
|
|
self.assertEqual(files[0]["file"], "frame.png")
|
|
self.assertIn("mtime", files[0])
|
|
|
|
def test_counter_uses_highest_existing_file(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
for name in ("image_001.png", "image_004.png", "image_002.png.jpg"):
|
|
open(os.path.join(directory, name), "wb").close()
|
|
|
|
self.assertEqual(
|
|
self.nodes._next_counter_for_relative_path(directory, "image_%counter%.png"),
|
|
5,
|
|
)
|
|
|
|
def test_counter_can_be_in_a_folder_name(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
os.makedirs(os.path.join(directory, "renders001"))
|
|
os.makedirs(os.path.join(directory, "renders004"))
|
|
open(os.path.join(directory, "renders001", "cover.png"), "wb").close()
|
|
open(os.path.join(directory, "renders004", "cover.png"), "wb").close()
|
|
|
|
self.assertEqual(
|
|
self.nodes._next_counter_for_relative_path(
|
|
directory, "renders%counter%/cover.png"
|
|
),
|
|
5,
|
|
)
|
|
|
|
def test_save_batch_assigns_distinct_counter_names(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
FakeImage.saved_paths.clear()
|
|
node = self.nodes.DumasSaveImageNode()
|
|
node.save_images(
|
|
[FakeBatch(), FakeBatch()],
|
|
directory,
|
|
"batch_%counter%",
|
|
"png",
|
|
95,
|
|
False,
|
|
True,
|
|
)
|
|
node.save_images(
|
|
[FakeBatch(), FakeBatch()],
|
|
directory,
|
|
"batch_%counter%",
|
|
"png",
|
|
95,
|
|
False,
|
|
True,
|
|
)
|
|
|
|
self.assertEqual(
|
|
[os.path.basename(path) for path, _args, _kwargs in FakeImage.saved_paths[-2:]],
|
|
["batch_003.png", "batch_004.png"],
|
|
)
|
|
|
|
def test_save_without_counter_token_does_not_overwrite(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
FakeImage.saved_paths.clear()
|
|
nested = os.path.join(directory, "renders")
|
|
os.makedirs(nested)
|
|
open(os.path.join(nested, "cover.png"), "wb").close()
|
|
self.nodes.DumasSaveImageNode().save_images(
|
|
[FakeBatch()], directory, "renders/cover", "png", 95, False, True
|
|
)
|
|
|
|
self.assertEqual(
|
|
os.path.basename(FakeImage.saved_paths[-1][0]),
|
|
"cover_001.png",
|
|
)
|
|
self.assertEqual(
|
|
os.path.dirname(FakeImage.saved_paths[-1][0]),
|
|
nested,
|
|
)
|
|
|
|
def test_preview_mode_writes_temp_images_without_touching_destination(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
FakeImage.saved_paths.clear()
|
|
self.nodes.DumasSaveImageNode().save_images(
|
|
[FakeBatch()], directory, "preview_%counter%", "webp", 90, False, False
|
|
)
|
|
|
|
self.assertEqual(len(FakeImage.saved_paths), 1)
|
|
saved_path = FakeImage.saved_paths[-1][0]
|
|
self.assertTrue(str(saved_path).startswith(self.temp_dir))
|
|
self.assertTrue(str(saved_path).endswith(".webp"))
|
|
self.assertFalse(os.path.exists(os.path.join(directory, "preview_001.webp")))
|
|
result = self.nodes.DumasSaveImageNode().save_images(
|
|
[FakeBatch()], directory, "preview_%counter%", "webp", 90, False, False
|
|
)
|
|
self.assertEqual(result["result"][1], self.temp_dir)
|
|
self.assertEqual(len(result["result"][2]), 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|