griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
b278e37f70d562a3c97543d6171403e0ce913aa4
test/tests/python/bl_pyapi_idprop.py
Bastien Montagne b278e37f70 IDProps: Make 'dynamic RNA' IDProperties statically typed. 
All IDProperties generated as part of 'storage backend' for dynamic RNA
properties are now statically typed.

Also adds some basic unittests for the new statically typed IDProperty
system, based on py-defined RNA data.

Ref. #122743.
2024-06-13 19:58:22 +02:00

563 lines
24 KiB
Python
Raw Blame History

# SPDX-FileCopyrightText: 2017-2022 Blender Authors
#
# SPDX-License-Identifier: Apache-2.0
# ./blender.bin --background --python tests/python/bl_pyapi_idprop.py -- --verbose
import bpy
import rna_prop_ui
import idprop
import unittest
from array import array
# Run if `numpy` is installed.
try:
import numpy as np
except ImportError:
np = None
class TestHelper:
@property
def id(self):
return self._id
def setUp(self):
self._id = bpy.context.scene
self._id.pop("cycles", None)
assert len(self._id.keys()) == 0
def tearDown(self):
for key in list(self._id.keys()):
del self._id[key]
def assertAlmostEqualSeq(self, list1, list2):
self.assertEqual(len(list1), len(list2))
for v1, v2 in zip(list1, list2):
self.assertAlmostEqual(v1, v2, places=5)
class TestIdPropertyCreation(TestHelper, unittest.TestCase):
# Default testing idprop key identifier.
key_id = "a"
def test_name_empty(self):
key_id = ""
value = 4
self.id[key_id] = value
self.assertEqual(self.id[key_id], value)
def test_name_too_long(self):
with self.assertRaises(KeyError):
self.id["name" * 30] = 4
def test_int(self):
value = 2
self.id[self.key_id] = value
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], int))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
with self.assertRaises(OverflowError):
self.id[self.key_id] = 2 ** 31 # integer <= 2 ** 31-1
def test_double(self):
value = 2.5
self.id[self.key_id] = value
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], float))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_unicode(self):
value = "Hello World"
self.id[self.key_id] = value
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], str))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_bytes(self):
value = b"Hello World"
self.id[self.key_id] = value
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], bytes))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_enum(self):
# Note: Fake enum, this merely creates a PROP_INT idprop.
value = 5
self.id[self.key_id] = value
self.assertEqual(self.id[self.key_id], value)
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_double_list(self):
mylist = [1.2, 3.4, 5.6]
self.id[self.key_id] = mylist
self.assertEqual(self.id[self.key_id].to_list(), mylist)
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_int_list(self):
mylist = [1, 2, 3]
self.id[self.key_id] = mylist
self.assertEqual(self.id[self.key_id].to_list(), mylist)
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_float_array(self):
mylist = [1.2, 3.4, 5.6]
self.id[self.key_id] = array("f", mylist)
self.assertAlmostEqualSeq(self.id[self.key_id].to_list(), mylist)
self.assertEqual(self.id[self.key_id].typecode, "f")
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_double_array(self):
mylist = [1.2, 3.4, 5.6]
self.id[self.key_id] = array("d", mylist)
self.assertAlmostEqualSeq(self.id[self.key_id].to_list(), mylist)
self.assertEqual(self.id[self.key_id].typecode, "d")
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_int_array(self):
mylist = [1, 2, 3]
self.id[self.key_id] = array("i", mylist)
self.assertAlmostEqualSeq(self.id[self.key_id].to_list(), mylist)
self.assertEqual(self.id[self.key_id].typecode, "i")
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_other_array(self):
mylist = [1, 2, 3]
self.id[self.key_id] = array("Q", mylist)
self.assertEqual(self.id[self.key_id].to_list(), mylist)
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_mixed_numerical_type(self):
self.id[self.key_id] = [1, 2, 3.4, 5]
self.assertAlmostEqualSeq(self.id[self.key_id].to_list(), [1.0, 2.0, 3.4, 5.0])
self.assertEqual(self.id[self.key_id].typecode, "d")
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_str_list(self):
# I'm a bit surprised that this works
mylist = ["abc", "qwe"]
self.id[self.key_id] = mylist
self.assertEqual(self.id[self.key_id], mylist)
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_sequence_mixed_type(self):
with self.assertRaises(TypeError):
mylist = ["abc", 3, "qwe", 3.4]
self.id[self.key_id] = mylist
def test_mapping_simple(self):
mydict = {"1": 10, "2": "20", "3": 30.5}
self.id[self.key_id] = mydict
self.assertEqual(self.id[self.key_id]["1"], mydict["1"])
self.assertEqual(self.id[self.key_id]["2"], mydict["2"])
self.assertEqual(self.id[self.key_id]["3"], mydict["3"])
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_mapping_complex(self):
mydict = {
"1": [1, 2, 3],
"2": {"1": "abc", "2": array("i", [4, 5, 6])},
"3": {"1": {"1": 10}, "2": b"qwe"},
}
self.id[self.key_id] = mydict
self.assertEqual(self.id[self.key_id]["1"].to_list(), [1, 2, 3])
self.assertEqual(self.id[self.key_id]["2"]["1"], "abc")
self.assertEqual(self.id[self.key_id]["2"]["2"].to_list(), [4, 5, 6])
self.assertEqual(self.id[self.key_id]["3"]["1"]["1"], 10)
self.assertEqual(self.id[self.key_id]["3"]["2"], b"qwe")
# Complex types currently return different object types.
# self.assertEqual(self.id[self.key_id],
# self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
with self.assertRaises(KeyError):
a = self.id[self.key_id]["2"]["a"]
def test_invalid_type(self):
with self.assertRaises(TypeError):
self.id[self.key_id] = self
class TestIdPropertyUIData(TestHelper, unittest.TestCase):
# Default testing idprop key identifier.
key_id = "a"
def test_int(self):
value = 2
rna_prop_ui.rna_idprop_ui_create(self.id, self.key_id, default=value)
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], int))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_double(self):
value = 2.5
rna_prop_ui.rna_idprop_ui_create(self.id, self.key_id, default=value)
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], float))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
def test_unicode(self):
value = "Hello World"
rna_prop_ui.rna_idprop_ui_create(self.id, self.key_id, default=value)
self.assertEqual(self.id[self.key_id], value)
self.assertTrue(isinstance(self.id[self.key_id], str))
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
# NOTE: Bytes strings are not supported currently.
def test_enum(self):
value = 1
items = [('A', '', ''), ('B', '', '')]
rna_prop_ui.rna_idprop_ui_create(self.id, self.key_id, default=value, items=items)
# 'Enum' 'type' of idprop currently returns integer value for direct subscription,
# and string key for `path_resolve` usage. See also #122843 .
self.assertEqual(self.id[self.key_id], value)
if False: # FIXME
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
else:
self.assertEqual(self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)), 'B')
self.assertEqual(self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)), 'B')
self.id[self.key_id] = 0
self.assertEqual(self.id[self.key_id], 0)
if False: # FIXME
self.assertEqual(self.id[self.key_id],
self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)))
else:
self.assertEqual(self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(self.key_id)), 'A')
# Check statically typed underlying IDProperties storage for dynamic RNA properties.
class TestIdPropertyDynamicRNA(TestHelper, unittest.TestCase):
class TestDynRNAClass(bpy.types.PropertyGroup):
string_prop: bpy.props.StringProperty()
int_prop: bpy.props.IntProperty()
float_array_prop: bpy.props.FloatVectorProperty(size=[3])
def setUp(self):
super().setUp()
bpy.utils.register_class(self.TestDynRNAClass)
assert(type(self.id) == bpy.types.Scene)
bpy.types.Scene.dynrna_prop = bpy.props.PointerProperty(type=self.TestDynRNAClass)
assert(hasattr(self.id, "dynrna_prop"))
def tearDown(self):
del bpy.types.Scene.dynrna_prop
bpy.utils.unregister_class(self.TestDynRNAClass)
super().tearDown()
def test_dynamic_rna_basics(self):
# The IDP_Group matching a registered RNA Pointer property to a registered
# PropertyGroup type always exists.
self.assertTrue('dynrna_prop' in self.id)
# However, the underlying idprop data for each property of the PropertyGroup
# does not exist untill set through an RNA property access.
self.assertTrue(len(self.id['dynrna_prop']) == 0)
self.id.dynrna_prop.string_prop = "Test String"
self.assertTrue(len(self.id['dynrna_prop']) == 1)
self.assertEqual(self.id.dynrna_prop.string_prop, self.id['dynrna_prop']['string_prop'])
self.id['dynrna_prop']['string_prop'] = "String test"
self.assertEqual(self.id.dynrna_prop.string_prop, self.id['dynrna_prop']['string_prop'])
self.id.dynrna_prop.int_prop = 1
self.assertTrue(len(self.id['dynrna_prop']) == 2)
self.assertEqual(self.id.dynrna_prop.int_prop, self.id['dynrna_prop']['int_prop'])
self.id['dynrna_prop']['int_prop'] = 33
self.assertEqual(self.id.dynrna_prop.int_prop, self.id['dynrna_prop']['int_prop'])
self.id.dynrna_prop.float_array_prop = [1.0, 2.0, 3.0]
self.assertTrue(len(self.id['dynrna_prop']) == 3)
self.assertEqual(list(self.id.dynrna_prop.float_array_prop), list(self.id['dynrna_prop']['float_array_prop']))
self.id['dynrna_prop']['float_array_prop'] = [0.1, 1.0, 10.0]
self.assertEqual(list(self.id.dynrna_prop.float_array_prop), list(self.id['dynrna_prop']['float_array_prop']))
def test_static_type(self):
# Check that the idproperty behind the defined RNA ones are statically typed, and cannot be
# assigned random other types of values.
self.id.dynrna_prop.string_prop = "Test String"
self.id.dynrna_prop.int_prop = 1
self.id.dynrna_prop.float_array_prop = [1.0, 2.0, 3.0]
with self.assertRaises(TypeError):
self.id['dynrna_prop']['string_prop'] = b"Test String"
# Supported conversion from bool to int.
self.id['dynrna_prop']['int_prop'] = False
self.assertEqual(self.id['dynrna_prop']['int_prop'], 0)
self.assertEqual(self.id.dynrna_prop.int_prop, self.id['dynrna_prop']['int_prop'])
self.assertEqual(type(self.id['dynrna_prop']['int_prop']), int)
with self.assertRaises(TypeError):
self.id['dynrna_prop']['int_prop'] = 2.5
with self.assertRaises(TypeError):
self.id['dynrna_prop']['int_prop'] = "100"
mixed_array = [5, 2.5, 2]
self.id['dynrna_prop']['float_array_prop'] = mixed_array
self.assertEqual(list(self.id['dynrna_prop']['float_array_prop']), mixed_array)
self.assertEqual(list(self.id.dynrna_prop.float_array_prop), list(self.id['dynrna_prop']['float_array_prop']))
self.assertTrue(all((type(i) is float for i in self.id['dynrna_prop']['float_array_prop'])))
with self.assertRaises(TypeError):
self.id['dynrna_prop']['float_array_prop'] = 2.5
with self.assertRaises(TypeError):
self.id['dynrna_prop']['float_array_prop'] = [True, False, False]
# Length of the array is also considered as static/fixed.
with self.assertRaises(TypeError):
self.id['dynrna_prop']['float_array_prop'] = [5.0, 2.5]
with self.assertRaises(TypeError):
self.id['dynrna_prop']['float_array_prop'] = [1.0, 10.0, 100.0, 0.1]
class TestIdPropertyGroupView(TestHelper, unittest.TestCase):
def test_type(self):
self.assertEqual(type(self.id.keys()), idprop.types.IDPropertyGroupViewKeys)
self.assertEqual(type(self.id.values()), idprop.types.IDPropertyGroupViewValues)
self.assertEqual(type(self.id.items()), idprop.types.IDPropertyGroupViewItems)
self.assertEqual(type(iter(self.id.keys())), idprop.types.IDPropertyGroupIterKeys)
self.assertEqual(type(iter(self.id.values())), idprop.types.IDPropertyGroupIterValues)
self.assertEqual(type(iter(self.id.items())), idprop.types.IDPropertyGroupIterItems)
def test_basic(self):
text = ["A", "B", "C"]
for i, ch in enumerate(text):
self.id[ch] = i
self.assertEqual(len(self.id.keys()), len(text))
self.assertEqual(list(self.id.keys()), text)
self.assertEqual(list(reversed(self.id.keys())), list(reversed(text)))
self.assertEqual(len(self.id.values()), len(text))
self.assertEqual(list(self.id.values()), list(range(len(text))))
self.assertEqual(list(reversed(self.id.values())), list(reversed(range(len(text)))))
self.assertEqual(len(self.id.items()), len(text))
self.assertEqual(list(self.id.items()), [(k, v) for v, k in enumerate(text)])
self.assertEqual(list(reversed(self.id.items())), list(reversed([(k, v) for v, k in enumerate(text)])))
# Check direct iteration is working as expected.
self.id["group"] = {ch: i for i, ch in enumerate(text)}
group = self.id["group"]
self.assertEqual(len(group), len(text))
self.assertEqual(list(iter(group)), text)
def test_contains(self):
# Check `idprop.types.IDPropertyGroupView{Keys/Values/Items}.__contains__`
text = ["A", "B", "C"]
for i, ch in enumerate(text):
self.id[ch] = i
self.assertIn("A", self.id)
self.assertNotIn("D", self.id)
self.assertIn("A", self.id.keys())
self.assertNotIn("D", self.id.keys())
self.assertIn(2, self.id.values())
self.assertNotIn(3, self.id.values())
self.assertIn(("A", 0), self.id.items())
self.assertNotIn(("D", 3), self.id.items())
class TestBufferProtocol(TestHelper, unittest.TestCase):
def test_copy(self):
self.id["a"] = array("i", [1, 2, 3, 4, 5])
self.id["b"] = self.id["a"]
self.assertEqual(self.id["a"].to_list(), self.id["b"].to_list())
def test_memview_attributes(self):
mylist = [1, 2, 3]
self.id["a"] = mylist
view1 = memoryview(self.id["a"])
view2 = memoryview(array("i", mylist))
self.assertEqualMemviews(view1, view2)
def assertEqualMemviews(self, view1, view2):
props_to_compare = (
"contiguous", "format", "itemsize", "nbytes", "ndim",
"readonly", "shape", "strides", "suboffsets",
)
for attr in props_to_compare:
self.assertEqual(getattr(view1, attr), getattr(view2, attr))
self.assertEqual(list(view1), list(view2))
self.assertEqual(view1.tobytes(), view2.tobytes())
if np is not None:
class TestBufferProtocol_Numpy(TestHelper, unittest.TestCase):
def test_int(self):
self.id["a"] = array("i", [1, 2, 3, 4, 5])
a = np.frombuffer(self.id["a"], self.id["a"].typecode)
self.assertEqual(len(a), 5)
a[2] = 10
self.assertEqual(self.id["a"].to_list(), [1, 2, 10, 4, 5])
def test_float(self):
self.id["a"] = array("f", [1.0, 2.0, 3.0, 4.0])
a = np.frombuffer(self.id["a"], self.id["a"].typecode)
self.assertEqual(len(a), 4)
a[-1] = 10
self.assertEqual(self.id["a"].to_list(), [1.0, 2.0, 3.0, 10.0])
def test_double(self):
self.id["a"] = array("d", [1.0, 2.0, 3.0, 4.0])
a = np.frombuffer(self.id["a"], self.id["a"].typecode)
a[1] = 10
self.assertEqual(self.id["a"].to_list(), [1.0, 10.0, 3.0, 4.0])
def test_full_update(self):
self.id["a"] = array("i", [1, 2, 3, 4, 5, 6])
a = np.frombuffer(self.id["a"], self.id["a"].typecode)
a[:] = [10, 20, 30, 40, 50, 60]
self.assertEqual(self.id["a"].to_list(), [10, 20, 30, 40, 50, 60])
def test_partial_update(self):
self.id["a"] = array("i", [1, 2, 3, 4, 5, 6, 7, 8])
a = np.frombuffer(self.id["a"], self.id["a"].typecode)
a[1:5] = [10, 20, 30, 40]
self.assertEqual(self.id["a"].to_list(), [1, 10, 20, 30, 40, 6, 7, 8])
class TestRNAData(TestHelper, unittest.TestCase):
def test_custom_properties_access(self):
# Ensure the RNA path resolving behaves as expected & is compatible with ID-property keys.
keys_to_test = (
"test",
"\\"
'"',
'""',
'"""',
'[',
']',
'[]',
'["]',
'[""]',
'["""]',
'[""""]',
# Empty properties are also valid.
"",
)
for key_id in keys_to_test:
self.id[key_id] = 1
self.assertEqual(self.id[key_id], self.id.path_resolve('["%s"]' % bpy.utils.escape_identifier(key_id)))
del self.id[key_id]
def test_custom_properties_none(self):
bpy.data.objects.new("test", None)
test_object = bpy.data.objects["test"]
# Access default RNA data values.
test_object.id_properties_clear()
test_object["test_prop"] = 0.5
ui_data_test_prop = test_object.id_properties_ui("test_prop")
rna_data = ui_data_test_prop.as_dict()
self.assertTrue("min" in rna_data)
self.assertLess(rna_data["min"], -10000.0)
self.assertEqual(rna_data["subtype"], "NONE")
self.assertGreater(rna_data["soft_max"], 10000.0)
# Change RNA data values.
ui_data_test_prop.update(subtype="TEMPERATURE", min=0, soft_min=0.1)
rna_data = ui_data_test_prop.as_dict()
self.assertEqual(rna_data["min"], 0)
self.assertEqual(rna_data["soft_min"], 0.1)
self.assertEqual(rna_data["subtype"], "TEMPERATURE")
# Copy RNA data values from one property to another.
test_object["test_prop_2"] = 11.7
ui_data_test_prop_2 = test_object.id_properties_ui("test_prop_2")
ui_data_test_prop_2.update_from(ui_data_test_prop)
rna_data = ui_data_test_prop_2.as_dict()
self.assertEqual(rna_data["min"], 0)
self.assertEqual(rna_data["soft_min"], 0.1)
self.assertEqual(rna_data["subtype"], "TEMPERATURE")
self.assertGreater(rna_data["soft_max"], 10000.0)
# Copy RNA data values to another object's property.
bpy.data.objects.new("test_2", None)
test_object_2 = bpy.data.objects["test_2"]
test_object_2["test_prop_3"] = 20.1
ui_data_test_prop_3 = test_object_2.id_properties_ui("test_prop_3")
ui_data_test_prop_3.update_from(ui_data_test_prop_2)
rna_data = ui_data_test_prop_3.as_dict()
self.assertEqual(rna_data["min"], 0)
self.assertEqual(rna_data["soft_min"], 0.1)
self.assertEqual(rna_data["subtype"], "TEMPERATURE")
self.assertGreater(rna_data["soft_max"], 10000.0)
# Test RNA data for string property.
test_object.id_properties_clear()
test_object["test_string_prop"] = "Hello there!"
ui_data_test_prop_string = test_object.id_properties_ui("test_string_prop")
ui_data_test_prop_string.update(default="Goodbye where?")
rna_data = ui_data_test_prop_string.as_dict()
self.assertEqual(rna_data["default"], "Goodbye where?")
# Test RNA data for array property.
test_object.id_properties_clear()
test_object["test_array_prop"] = [1, 2, 3]
ui_data_test_prop_array = test_object.id_properties_ui("test_array_prop")
ui_data_test_prop_array.update(default=[1, 2])
rna_data = ui_data_test_prop_array.as_dict()
self.assertEqual(rna_data["default"], [1, 2])
# Test RNA data for enum property.
test_object.id_properties_clear()
test_object["test_enum_prop"] = 2
ui_data_test_prop_enum = test_object.id_properties_ui("test_enum_prop")
ui_data_test_prop_enum_items = [
("TOMATOES", "Tomatoes", "Solanum lycopersicum"),
("CUCUMBERS", "Cucumbers", "Cucumis sativus"),
("RADISHES", "Radishes", "Raphanus raphanistrum"),
]
ui_data_test_prop_enum.update(items=ui_data_test_prop_enum_items)
ui_data_test_prop_enum_items_full = [
("TOMATOES", "Tomatoes", "Solanum lycopersicum", 0, 0),
("CUCUMBERS", "Cucumbers", "Cucumis sativus", 0, 1),
("RADISHES", "Radishes", "Raphanus raphanistrum", 0, 2),
]
rna_data = ui_data_test_prop_enum.as_dict()
self.assertEqual(rna_data["items"], ui_data_test_prop_enum_items_full)
if __name__ == '__main__':
import sys
sys.argv = [__file__] + (sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else [])
unittest.main()
Reference in New Issue View Git Blame Copy Permalink