208 lines
7.3 KiB
Python
208 lines
7.3 KiB
Python
"""
|
|
Unit tests for ComfyUI Selector nodes.
|
|
"""
|
|
|
|
import pytest # noqa: F401
|
|
|
|
|
|
class TestNodeStructure:
|
|
"""Test that all nodes have the required ComfyUI structure."""
|
|
|
|
def test_node_has_required_attributes(self, all_nodes):
|
|
"""Test that each node has all required ComfyUI attributes."""
|
|
required_attrs = ["INPUT_TYPES", "RETURN_TYPES", "FUNCTION", "CATEGORY"]
|
|
|
|
for node_name, node_class in all_nodes.items():
|
|
for attr in required_attrs:
|
|
assert hasattr(
|
|
node_class, attr
|
|
), f"{node_name} missing required attribute: {attr}"
|
|
|
|
def test_input_types_method(self, all_nodes):
|
|
"""Test that INPUT_TYPES() method returns valid structure."""
|
|
for node_name, node_class in all_nodes.items():
|
|
input_types = node_class.INPUT_TYPES()
|
|
assert isinstance(
|
|
input_types, dict
|
|
), f"{node_name}.INPUT_TYPES() must return a dict"
|
|
assert (
|
|
"required" in input_types
|
|
), f"{node_name}.INPUT_TYPES() must have 'required' key"
|
|
|
|
def test_function_method_exists(self, all_nodes):
|
|
"""Test that the function method specified in FUNCTION exists."""
|
|
for node_name, node_class in all_nodes.items():
|
|
function_name = node_class.FUNCTION
|
|
assert hasattr(
|
|
node_class, function_name
|
|
), f"{node_name} missing function method: {function_name}"
|
|
|
|
def test_node_instantiation(self, all_nodes):
|
|
"""Test that all nodes can be instantiated."""
|
|
for node_name, node_class in all_nodes.items():
|
|
instance = node_class()
|
|
assert instance is not None, f"{node_name} failed to instantiate"
|
|
|
|
|
|
class TestSamplerSelector:
|
|
"""Test SamplerSelector node functionality."""
|
|
|
|
def test_select_sampler(self, sampler_selector):
|
|
"""Test sampler selection."""
|
|
result = sampler_selector.select_sampler("euler")
|
|
assert result == ("euler",)
|
|
|
|
def test_input_types(self, sampler_selector):
|
|
"""Test input types structure."""
|
|
input_types = sampler_selector.INPUT_TYPES()
|
|
assert "sampler_name" in input_types["required"]
|
|
|
|
def test_return_types(self, sampler_selector):
|
|
"""Test return types."""
|
|
assert len(sampler_selector.RETURN_TYPES) == 1
|
|
assert isinstance(sampler_selector.RETURN_TYPES[0], list)
|
|
|
|
def test_category(self, sampler_selector):
|
|
"""Test node category."""
|
|
assert sampler_selector.CATEGORY == "comfyassets/Sampling"
|
|
|
|
|
|
class TestSchedulerSelector:
|
|
"""Test SchedulerSelector node functionality."""
|
|
|
|
def test_select_scheduler(self, scheduler_selector):
|
|
"""Test scheduler selection."""
|
|
result = scheduler_selector.select_scheduler("karras")
|
|
assert result == ("karras",)
|
|
|
|
def test_input_types(self, scheduler_selector):
|
|
"""Test input types structure."""
|
|
input_types = scheduler_selector.INPUT_TYPES()
|
|
assert "scheduler" in input_types["required"]
|
|
|
|
def test_category(self, scheduler_selector):
|
|
"""Test node category."""
|
|
assert scheduler_selector.CATEGORY == "comfyassets/Sampling"
|
|
|
|
|
|
class TestSeedHistory:
|
|
"""Test SeedHistory node functionality."""
|
|
|
|
def test_output_seed_basic(self, seed_history):
|
|
"""Test basic seed output."""
|
|
result = seed_history.output_seed(42)
|
|
assert result == (42,)
|
|
|
|
def test_output_seed_different_values(self, seed_history):
|
|
"""Test seed output with different values."""
|
|
result = seed_history.output_seed(123)
|
|
assert result == (123,)
|
|
|
|
def test_output_seed_passthrough(self, seed_history):
|
|
"""Test that seed is passed through unchanged."""
|
|
result = seed_history.output_seed(999)
|
|
assert isinstance(result[0], int)
|
|
assert result[0] == 999
|
|
|
|
def test_output_seed_large_values(self, seed_history):
|
|
"""Test seed output with large values."""
|
|
large_seed = 0xFFFFFFFFFFFFFFFF
|
|
result = seed_history.output_seed(large_seed)
|
|
assert result == (large_seed,)
|
|
|
|
def test_output_seed_zero(self, seed_history):
|
|
"""Test seed output with zero value."""
|
|
result = seed_history.output_seed(0)
|
|
assert result == (0,)
|
|
|
|
def test_input_types_structure(self, seed_history):
|
|
"""Test that input types are correctly configured."""
|
|
input_types = seed_history.INPUT_TYPES()
|
|
assert "required" in input_types
|
|
assert "seed" in input_types["required"]
|
|
|
|
seed_config = input_types["required"]["seed"]
|
|
assert seed_config[0] == "INT"
|
|
assert "default" in seed_config[1]
|
|
assert "min" in seed_config[1]
|
|
assert "max" in seed_config[1]
|
|
assert "tooltip" in seed_config[1]
|
|
|
|
# Test default value
|
|
assert seed_config[1]["default"] == 12345
|
|
assert seed_config[1]["min"] == 0
|
|
assert seed_config[1]["max"] == 0xFFFFFFFFFFFFFFFF
|
|
|
|
def test_return_types(self, seed_history):
|
|
"""Test return types configuration."""
|
|
assert seed_history.RETURN_TYPES == ("INT",)
|
|
assert seed_history.RETURN_NAMES == ("seed",)
|
|
|
|
def test_function_name(self, seed_history):
|
|
"""Test function name matches method."""
|
|
assert seed_history.FUNCTION == "output_seed"
|
|
assert hasattr(seed_history, "output_seed")
|
|
|
|
def test_category(self, seed_history):
|
|
"""Test node category."""
|
|
assert seed_history.CATEGORY == "comfyassets/Generation"
|
|
|
|
|
|
class TestWidthNode:
|
|
"""Test WidthNode functionality."""
|
|
|
|
def test_custom_width(self, width_node):
|
|
"""Test custom width selection."""
|
|
result = width_node.get_width(512, "custom")
|
|
assert result == (512,)
|
|
|
|
def test_preset_width(self, width_node):
|
|
"""Test preset width selection."""
|
|
result = width_node.get_width(512, "1024")
|
|
assert result == (1024,)
|
|
|
|
def test_category(self, width_node):
|
|
"""Test node category."""
|
|
assert width_node.CATEGORY == "comfyassets/Dimensions"
|
|
|
|
|
|
class TestHeightNode:
|
|
"""Test HeightNode functionality."""
|
|
|
|
def test_custom_height(self, height_node):
|
|
"""Test custom height selection."""
|
|
result = height_node.get_height(512, "custom")
|
|
assert result == (512,)
|
|
|
|
def test_preset_height(self, height_node):
|
|
"""Test preset height selection."""
|
|
result = height_node.get_height(512, "768")
|
|
assert result == (768,)
|
|
|
|
def test_category(self, height_node):
|
|
"""Test node category."""
|
|
assert height_node.CATEGORY == "comfyassets/Dimensions"
|
|
|
|
|
|
class TestWidthHeightNode:
|
|
"""Test WidthHeightNode functionality."""
|
|
|
|
def test_custom_dimensions(self, width_height_node):
|
|
"""Test custom dimensions."""
|
|
result = width_height_node.get_dimensions(512, 768, "custom", False)
|
|
assert result == (512, 768)
|
|
|
|
def test_preset_dimensions(self, width_height_node):
|
|
"""Test preset dimensions."""
|
|
result = width_height_node.get_dimensions(512, 768, "1024x768", False)
|
|
assert result == (1024, 768)
|
|
|
|
def test_swap_dimensions(self, width_height_node):
|
|
"""Test dimension swapping."""
|
|
result = width_height_node.get_dimensions(512, 768, "custom", True)
|
|
assert result == (768, 512)
|
|
|
|
def test_category(self, width_height_node):
|
|
"""Test node category."""
|
|
assert width_height_node.CATEGORY == "comfyassets/Dimensions"
|