[ui] Attribute/Node: Add tests for validators and refacto some methods

Author: nicolas-lambert-tc

meshroom/core/attribute.py

@@ -446,13 +446,13 @@ def getPrimitiveValue(self, exportDefault=True):
     def updateInternals(self):
         # Emit if the enable status has changed
         self.setEnabled(self.getEnabled())
-
+    
     def getErrorMessages(self) -> list[str]:
         """ Execute the validators and aggregate the eventual error messages"""
 
         result = []
 
-        for validator in self.desc._validators:
+        for validator in self.desc.validators:
             isValid, errorMessages = validator(self.node, self)
 
             if isValid:
@@ -463,6 +463,18 @@ def getErrorMessages(self) -> list[str]:
 
         return result
 
+    def _isValid(self) -> bool:
+        """ Check the validation and return False if any validator return (False, erorrs)
+        """
+
+        for validator in self.desc.validators:
+            isValid, _ = validator(self.node, self)
+
+            if not isValid:
+                return False
+        
+        return True
+     
     def _isMandatory(self) -> bool:
         """ An attribute is considered as mandatory it contain a NotEmptyValidator """
 
@@ -519,7 +531,7 @@ def _isMandatory(self) -> bool:
     errorMessageChanged = Signal()
     errorMessages = Property(Variant, lambda self: self.getErrorMessages(), notify=errorMessageChanged)
     isMandatory = Property(bool, _isMandatory, constant=True )
-
+    isValid = Property(bool, _isValid, constant=True)
 
 def raiseIfLink(func):
     """ If Attribute instance is a link, raise a RuntimeError."""

meshroom/core/desc/validators.py

@@ -6,7 +6,6 @@
 
 
 SuccessResponse = (True, [])
-Number = TypeVar("Number", int, float)
 
 
 class AttributeValidator(object):
@@ -26,15 +25,11 @@ def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str
 
 class RangeValidator(AttributeValidator):
 
-    def __init__(self, min:Number, max:Number):
+    def __init__(self, min, max):
         self._min = min
         self._max = max
 
     def __call__(self, node:"Node", attribute: "Attribute") -> tuple[bool, list[str]]:
-        
-        if not isinstance(attribute, Number):
-            return (False, ["Attribute value should be a number"])
-        
 
         if attribute.value < self._min or attribute.value > self._max:
             return (False, [f"Value should be greater than {self._min} and less than {self._max}", 

tests/nodes/test/validableNode.py

@@ -0,0 +1,43 @@
+from meshroom.core import desc
+from meshroom.core.desc.validators import NotEmptyValidator, RangeValidator
+
+
+class ValidableNode(desc.CommandLineNode):
+
+    inputs = [
+        desc.StringParam(
+            name='mandatory',
+            label='Mandatory input',
+            description='''''',
+            value='',
+            validators= [
+                NotEmptyValidator()
+            ]
+        ),
+        desc.FloatParam(
+            name='floatRange',
+            label='range input',
+            description='''''',
+            value=0.0,
+            validators=[
+                RangeValidator(min=0.0, max=1.0)
+            ]
+        ),
+        desc.IntParam(
+            name='intRange',
+            label='range input',
+            description='''''',
+            value=0.0,
+        ),
+
+    ]
+
+    outputs = [
+        desc.File(
+            name='output',
+            label='Output',
+            description='''''',
+            value='{nodeCacheFolder}/appendText.txt',
+        )
+    ]
+

tests/test_attributes.py

@@ -1,4 +1,15 @@
 from meshroom.core.graph import Graph
+from tests.nodes.test.validableNode import ValidableNode
+import pytest
+
+import logging
+logger = logging.getLogger('test')
+
+valid3DExtensionFiles = [(f'test.{ext}', True) for ext in ('obj', 'stl', 'fbx', 'gltf', 'abc', 'ply')]
+invalid3DExtensionFiles = [(f'test.{ext}', False) for ext in ('', 'exe', 'jpg', 'png', 'py')]
+
+valid2DSemantics= [(semantic, True) for semantic in ('image', 'imageList', 'sequence')]
+invalid2DSemantics = [(semantic, False) for semantic in ('3d', '', 'multiline', 'color/hue')]
 
 
 def test_attribute_retrieve_linked_input_and_output_attributes():
@@ -36,4 +47,103 @@ def test_attribute_retrieve_linked_input_and_output_attributes():
     assert not n0.output.hasOutputConnections
     assert len(n0.input.getLinkedInAttributes()) == 0
     assert len(n0.output.getLinkedOutAttributes()) == 0
-    
+
+@pytest.mark.parametrize("givenFile,expected", valid3DExtensionFiles + invalid3DExtensionFiles)
+def test_attribute_is3D_file_extensions(givenFile, expected):
+    """
+    Check what makes an attribute a valid 3d media
+    """
+
+    g = Graph('')
+    n0 = g.addNewNode('Ls', input='')
+
+    # Given
+    assert not n0.input.is3D
+
+    # When
+    n0.input.value = givenFile
+
+    # Then
+    assert n0.input.is3D == expected
+
+
+def test_attribute_i3D_by_description_semantic():
+    """ """
+
+    # Given
+    g = Graph('')
+    n0 = g.addNewNode('Ls', input='')  
+
+    assert not n0.output.is3D
+
+    # When
+    n0.output.desc._semantic = "3d"
+
+    # Then
+    assert n0.output.is3D
+
+@pytest.mark.parametrize("givenSemantic,expected", valid2DSemantics + invalid2DSemantics)
+def test_attribute_is2D_file_semantic(givenSemantic, expected):
+    """
+    Check what makes an attribute a valid 2d media
+    """
+
+    g = Graph('')
+    n0 = g.addNewNode('Ls', input='')
+
+    # Given
+    n0.input.desc._semantic = ""
+    assert not n0.input.is2D
+
+    # When
+    n0.input.desc._semantic = givenSemantic
+
+    # Then
+    assert n0.input.is2D == expected
+
+def test_attribute_notEmpty_validation():
+
+    # Given
+    g = Graph('')
+    node = g.addNewNode('ValidableNode')
+
+    # When
+    node.mandatory.value = ''
+
+    # Then
+    assert not node.mandatory.isValid
+    assert len(node.mandatory.getErrorMessages()) == 1
+    assert node.mandatory.isMandatory is True
+    assert node.hasInvalidAttribute
+
+    # When
+    node.mandatory.value = 'test'
+
+    # Then
+    assert node.mandatory.isValid
+    assert len(node.mandatory.getErrorMessages()) == 0
+    assert not node.hasInvalidAttribute
+
+def test_attribute_range_validation():
+
+    # Given
+    g = Graph('')
+    node = g.addNewNode('ValidableNode')
+    node.mandatory.value = 'test'
+
+    # When
+    node.floatRange.value = 2.0
+
+    # Then
+    assert not node.floatRange.isValid
+    assert len(node.floatRange.getErrorMessages()) == 2
+    assert node.mandatory.isMandatory is True
+    assert node.hasInvalidAttribute
+ 
+    # When
+    node.floatRange.value = 0.25
+
+    # Then
+    assert node.floatRange.isValid
+    assert len(node.mandatory.getErrorMessages()) == 0
+    assert not node.hasInvalidAttribute