test_attributes.py

import logging
import pytest

from meshroom.core.attribute import Attribute
from meshroom.core.graph import Graph
from tests.utils import registerNodeDesc
from tests.nodes.test.nodeValidators import NodeWithValidators

logger = logging.getLogger('test')

valid3DExtensionFiles = [(f'test.{ext}', True) for ext in ('obj', 'stl', 'fbx', 'gltf', 'abc', 'ply', 'usda', 'usdc')]
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')]

registerNodeDesc(NodeWithValidators)
validTextExtensionFiles = [(f'test{ext}', True) for ext in ('.txt', '.json', '.log', '.csv', '.md')]
invalidTextExtensionFiles = [(f'test{ext}', False) for ext in ('', '.exe', '.jpg', '.obj', '.py')]


def test_attribute_retrieve_linked_input_and_output_attributes():
    """
    Check that an attribute can retrieve the linked input and output attributes
    """

    # n0 -- n1 -- n2
    #   \          \
    #    ---------- n3

    g = Graph('')
    n0 = g.addNewNode('Ls', input='')
    n1 = g.addNewNode('Ls', input=n0.output)
    n2 = g.addNewNode('Ls', input=n1.output)
    n3 = g.addNewNode('AppendFiles', input=n1.output, input2=n2.output)

    # check that the attribute can retrieve its linked input attributes

    assert n0.output.hasAnyOutputLinks
    assert not n3.output.hasAnyOutputLinks

    assert len(n0.input.allInputLinks) == 0
    assert len(n1.input.allInputLinks) == 1
    assert n1.input.allInputLinks[0] == n0.output

    assert len(n1.output.allOutputLinks) == 2

    assert n1.output.allOutputLinks[0] == n2.input
    assert n1.output.allOutputLinks[1] == n3.input

    n0.graph = None

    # Bounding cases
    assert not n0.output.hasAnyOutputLinks
    assert len(n0.input.allInputLinks) == 0
    assert len(n0.output.allOutputLinks) == 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.is3dDisplayable

    # When
    n0.input.value = givenFile

    # Then
    assert n0.input.is3dDisplayable == expected

def test_attribute_i3D_by_description_semantic():
    """ """

    # Given
    g = Graph('')
    n0 = g.addNewNode('Ls', input='')

    assert not n0.output.is3dDisplayable

    # When
    n0.output.desc._semantic = "3d"

    # Then
    assert n0.output.is3dDisplayable


@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.is2dDisplayable

    # When
    n0.input.desc._semantic = givenSemantic

    # Then
    assert n0.input.is2dDisplayable == expected
    

def test_attribute_notEmpty_validation():

    # Given
    g = Graph('')
    node = g.addNewNode('NodeWithValidators')

    # 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('NodeWithValidators')
    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.floatRange.getErrorMessages()) == 0
    assert not node.hasInvalidAttribute


@pytest.mark.parametrize("givenFile,expected", validTextExtensionFiles + invalidTextExtensionFiles)
def test_attribute_isText_file_extensions(givenFile, expected):
    """
    Check what makes an attribute a valid text file
    """

    g = Graph('')
    n0 = g.addNewNode('Ls', input='')

    # Given
    assert not n0.input.isTextDisplayable

    # When
    n0.input.value = givenFile

    # Then
    assert n0.input.isTextDisplayable == expected


def test_attribute_isText_by_description_semantic():
    """
    Check that an attribute with semantic 'textFile' is considered a text file
    """

    # Given
    g = Graph('')
    n0 = g.addNewNode('Ls', input='')

    # The input attribute has an empty default value, so it is not text displayable
    assert not n0.input.isTextDisplayable

    # When
    n0.input.desc._semantic = "textFile"

    # Then
    assert n0.input.isTextDisplayable

def test_attribute_isInsideList():
    """
    Check whether an attribute is, either directly or indirectly, contained within a ListAttribute.
    """
    graph = Graph("")
    node = graph.addNewNode("GroupAttributes")

    # IntParam within a GroupAttribute: it has a parent, but it is not inside a list
    attr1 = node.attribute("firstGroup.firstGroupIntA")
    assert attr1.root
    assert attr1.depth == 1
    assert not attr1.isInsideList

    # FloatParam within a nested GroupAttribute: it has parents, but it is not inside a list
    attr2 = node.attribute("firstGroup.nestedGroup.nestedGroupFloat")
    assert attr2.root
    assert attr2.depth == 2
    assert not attr2.isInsideList

    # ListAttribute within a GroupAttribute: it has a parent but is not inside a list
    attr3 = node.attribute("firstGroup.singleGroupedList")
    assert attr3.root
    assert attr3.depth == 1
    assert not attr3.isInsideList

    # Insert an IntParam into the ListAttribute: the list attribute is not inside a list, but the IntParam is inside a list
    attr3.insert(0, 1)

    # Check that the value was correctly inserted
    assert isinstance(attr3.value[0], Attribute)
    assert attr3.value[0].value == 1

    assert not attr3.isInsideList  # Check that the ListAttribute itself is still not inside a list

    # Check that the IntParam inside the ListAttribute is considered to be inside a list
    assert attr3.value[0].root
    assert attr3.value[0].depth == 2
    assert attr3.value[0].isInsideList