def test_meta_node_validator(self):
node_name2 = cmds.createNode("transform")
meta_node2 = MetaNode(node_name2)
self.meta_node.add_field(MetaNodeValidator, "other_node", Accessibility.private)
self.meta_node.other_node.set(meta_node2)
self.meta_node.other_node.write()
self.assertEqual(cmds.getAttr("transform1.other_node"), meta_node2.uuid())
self.meta_node.other_node.read()
self.assertEqual(self.meta_node.other_node.get().uuid(), meta_node2.uuid())
class TestMetaNode(unittest.TestCase):
def setUp(self):
cmds.file(new=True, force=True)
node_name = cmds.createNode("transform")
self.meta_node = MetaNode(node_name)
def test_public_is_unlocked(self):
self.meta_node.add_field(IntValidator, "my_field", Accessibility.public)
self.assertFalse(cmds.getAttr(self.meta_node.my_field.path(), lock=True))
def test_public_is_unlocked_after_set(self):
self.meta_node.add_field(IntValidator, "my_field", Accessibility.public)
self.meta_node.my_field.set(10)
self.assertFalse(cmds.getAttr(self.meta_node.my_field.path(), lock=True))
def test_special_new_type(self):
class NewMetaNode(MetaNode):
pass
node = cmds.createNode("transform")
cmds.addAttr(node, longName="metanode_type", dataType="string")
cmds.setAttr("{}.metanode_type".format(node), "NewMetaNode", type="string")
rig = MetaNode(node)
self.assertTrue(isinstance(rig, NewMetaNode))
def test_add_default_fields(self):
node = cmds.createNode("transform")
default_field_names = ["metanode_fields", "metanode_type", "is_initialized"]
for field_name in default_field_names:
has_field = cmds.attributeQuery(field_name, node="transform2", exists=True)
self.assertFalse(has_field)
MetaNode(node)
for field_name in default_field_names:
has_field = cmds.attributeQuery(field_name, node="transform2", exists=True)
self.assertTrue(has_field)
def setUp(self):
cmds.file(new=True, force=True)
node_name = cmds.createNode("transform")
self.meta_node = MetaNode(node_name)
class TestValidators(unittest.TestCase):
def setUp(self):
cmds.file(new=True, force=True)
node_name = cmds.createNode("transform")
self.meta_node = MetaNode(node_name)
def test_int_validator(self):
self.meta_node.add_field(IntValidator, "jointCount", Accessibility.private)
self.meta_node.jointCount.set(10)
self.meta_node.jointCount.write()
self.assertEqual(cmds.getAttr("transform1.jointCount"), 10)
self.meta_node.jointCount.read()
self.assertEqual(self.meta_node.jointCount.get(), 10)
def test_float_validator(self):
self.meta_node.add_field(FloatValidator, "armLength", Accessibility.private)
self.meta_node.armLength.set(10)
self.meta_node.armLength.write()
self.assertEqual(cmds.getAttr("transform1.armLength"), 10)
self.meta_node.armLength.read()
self.assertEqual(self.meta_node.armLength.get(), 10)
def test_float_validator_translate_x(self):
self.meta_node.add_field(FloatValidator, "translateX", Accessibility.private)
self.meta_node.translateX.set(10)
self.meta_node.translateX.write()
self.assertEqual(cmds.getAttr("transform1.translateX"), 10)
self.meta_node.translateX.read()
self.assertEqual(self.meta_node.translateX.get(), 10)
def test_bool_validator(self):
self.meta_node.add_field(BoolValidator, "isItTrue", Accessibility.private)
self.meta_node.isItTrue.set(False)
self.meta_node.isItTrue.get()
self.assertEqual(cmds.getAttr("transform1.isItTrue"), 0)
self.assertEqual(self.meta_node.isItTrue.get(), False)
def test_string_validator(self):
self.meta_node.add_field(StringValidator, "my_name_is", Accessibility.private)
self.meta_node.my_name_is.set("Jeff")
self.meta_node.my_name_is.write()
self.assertEqual(cmds.getAttr("transform1.my_name_is"), "Jeff")
self.meta_node.my_name_is.read()
self.assertEqual(self.meta_node.my_name_is.get(), "Jeff")
def test_matrix_validator(self):
self.meta_node.add_field(MatrixValidator, "rest_matrix", Accessibility.private)
self.meta_node.rest_matrix.set(
# fmt: off
om2.MMatrix([
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
1, 2, 3, 1,
])
# fmt: on
)
self.meta_node.rest_matrix.write()
self.assertEqual(
cmds.getAttr("transform1.rest_matrix"),
# fmt: off
[
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
1, 2, 3, 1,
],
# fmt: on
)
self.meta_node.rest_matrix.read()
self.assertEqual(
self.meta_node.rest_matrix.get(),
# fmt: off
om2.MMatrix([
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
1, 2, 3, 1,
])
# fmt: on
)
def test_enum_validator(self):
class Axes(object):
X = 0
Y = 1
Z = 2
self.meta_node.add_field(
EnumValidator,
"upAxis",
Accessibility.private,
choices=["X", "Y", "Z"],
)
self.meta_node.upAxis.set(Axes.X)
self.assertEqual(cmds.getAttr("transform1.upAxis"), Axes.X)
self.assertEqual(self.meta_node.upAxis.get(), Axes.X)
def test_meta_node_validator(self):
node_name2 = cmds.createNode("transform")
meta_node2 = MetaNode(node_name2)
self.meta_node.add_field(MetaNodeValidator, "other_node", Accessibility.private)
self.meta_node.other_node.set(meta_node2)
self.meta_node.other_node.write()
self.assertEqual(cmds.getAttr("transform1.other_node"), meta_node2.uuid())
self.meta_node.other_node.read()
self.assertEqual(self.meta_node.other_node.get().uuid(), meta_node2.uuid())
def test_add_multi_field(self):
self.meta_node.add_field(
IntValidator,
"indices",
Accessibility.private,
multi=True,
)
self.meta_node.indices.set([0, 1, 2, 3])
self.meta_node.indices.write()
self.assertEqual(
# Please don't ask.
# Ok, Maya returned floats in a tuple in a list. Sad face is sad.
[int(index) for index in cmds.getAttr("transform1.indices")[0]],
[0, 1, 2, 3],
)
self.meta_node.indices.read()
self.assertEqual(self.meta_node.indices.get(), [0, 1, 2, 3])
def test_multi_field_clear(self):
self.meta_node.add_field(
IntValidator,
"indices",
Accessibility.private,
multi=True,
)
self.meta_node.indices.set([0, 1, 2, 3])
self.assertEqual(self.meta_node.indices.get(), [0, 1, 2, 3])
self.meta_node.indices.clear()
self.assertEqual(self.meta_node.indices.get(), [])
class TestMetaNode(unittest.TestCase):
def setUp(self):
cmds.file(new=True, force=True)
node_name = cmds.createNode("transform")
self.meta_node = MetaNode(node_name)
def test_new(self):
self.assertFalse(cmds.objExists("transform2"))
MetaNode.new("transform")
self.assertTrue(cmds.objExists("transform2"))
cmds.delete("transform2")
self.assertFalse(cmds.objExists("transform2"))
def test_special_new_type(self):
class NewMetaNode(MetaNode):
pass
node = cmds.createNode("transform")
cmds.addAttr(node, longName="metanode_type", dataType="string")
cmds.setAttr("{}.metanode_type".format(node), "NewMetaNode", type="string")
rig = MetaNode(node)
self.assertTrue(isinstance(rig, NewMetaNode))
def test_fails_on_non_string_init(self):
with self.assertRaises(TypeError) as context:
MetaNode(self.meta_node)
self.assertTrue("node name" in str(context.exception))
def test_fails_on_non_existing_node(self):
with self.assertRaises(ValueError) as context:
MetaNode("transform2")
self.assertTrue("does not exist" in str(context.exception))
def test_add_default_fields(self):
node = cmds.createNode("transform")
default_field_names = ["metanode_fields", "metanode_type", "is_initialized"]
for field_name in default_field_names:
has_field = cmds.attributeQuery(field_name, node="transform2", exists=True)
self.assertFalse(has_field)
MetaNode(node)
for field_name in default_field_names:
has_field = cmds.attributeQuery(field_name, node="transform2", exists=True)
self.assertTrue(has_field)
def test_add_field_updates_metanode_fields(self):
self.meta_node.add_field(IntValidator, "my_count", Accessibility.private)
self.meta_node.write_fields()
metanode_fields_raw = cmds.getAttr("transform1.metanode_fields")
fields_data = json.loads(metanode_fields_raw)
self.assertTrue("my_count" in fields_data)
self.assertEqual(
fields_data["my_count"],
{
"accessibility": 1,
"multi": False,
"validator": "IntValidator",
},
)
def test_serialize(self):
expected_data = {
"metanode_fields": {
"metanode_fields": {
"accessibility": 1,
"multi": False,
"validator": "JsonValidator",
},
"metanode_type": {
"accessibility": 1,
"multi": False,
"validator": "StringValidator",
},
"is_initialized": {
"accessibility": 1,
"multi": False,
"validator": "BoolValidator",
},
},
"metanode_type": "MetaNode",
"is_initialized": True,
}
self.meta_node.write_fields()
data = self.meta_node.serialize()
data.pop("uuid")
self.assertDictEqual(data, expected_data)
def test_name(self):
self.assertEqual(self.meta_node.name(), "transform1")
cmds.rename("transform1", "transform2")
self.assertEqual(self.meta_node.name(), "transform2")
def test_path(self):
self.assertEqual(self.meta_node.path(), "|transform1")
cmds.group("transform1")
self.assertEqual(self.meta_node.path(), "|group1|transform1")
def test_uuid(self):
self.assertEqual(self.meta_node.uuid(), cmds.ls("transform1", uuid=True)[0])
def test_same_instance(self):
other_metanode = MetaNode(self.meta_node.path())
self.assertTrue(self.meta_node is other_metanode)
def test_write_field(self):
self.meta_node.add_field(IntValidator, "my_count", Accessibility.private)
self.meta_node.my_count.set(10)
self.assertTrue(cmds.getAttr("{}.my_count".format(self.meta_node)) == 0)
self.meta_node.write_fields()
self.assertTrue(cmds.getAttr("{}.my_count".format(self.meta_node)) == 10)
def test_fails_on_non_existing_node(self):
with self.assertRaises(ValueError) as context:
MetaNode("transform2")
self.assertTrue("does not exist" in str(context.exception))
def test_fails_on_non_string_init(self):
with self.assertRaises(TypeError) as context:
MetaNode(self.meta_node)
self.assertTrue("node name" in str(context.exception))
def test_new(self):
self.assertFalse(cmds.objExists("transform2"))
MetaNode.new("transform")
self.assertTrue(cmds.objExists("transform2"))
cmds.delete("transform2")
self.assertFalse(cmds.objExists("transform2"))
def test_same_instance(self):
other_metanode = MetaNode(self.meta_node.path())
self.assertTrue(self.meta_node is other_metanode)