class TestSerialization(unittest.TestCase):
def setUp(self):
self.serialized = OrderedDict()
self.serialized["typeid"] = "malcolm:core/MethodMeta:1.0"
self.takes = MapMeta()
self.takes.set_elements(ElementMap({"in_attr": StringMeta("desc")}))
self.serialized["takes"] = self.takes.to_dict()
self.serialized["defaults"] = OrderedDict({"in_attr": "default"})
self.serialized["description"] = "test_description"
self.serialized["tags"] = []
self.serialized["writeable"] = True
self.serialized["label"] = ""
self.serialized["returns"] = MapMeta().to_dict()
def test_to_dict(self):
m = MethodMeta("test_description")
m.set_takes(self.takes)
m.set_defaults(self.serialized["defaults"])
self.assertEqual(m.to_dict(), self.serialized)
def test_from_dict(self):
m = MethodMeta.from_dict(self.serialized.copy())
self.assertEqual(m.takes.to_dict(), self.takes.to_dict())
self.assertEqual(m.defaults, self.serialized["defaults"])
self.assertEqual(m.tags, [])
self.assertEqual(m.writeable, True)
self.assertEqual(m.label, "")
self.assertEqual(m.returns.to_dict(), MapMeta().to_dict())
class TestSerialization(unittest.TestCase):
def setUp(self):
self.serialized = OrderedDict()
self.serialized["typeid"] = "malcolm:core/Method:1.0"
self.takes = MapMeta()
self.takes.set_elements({"in_attr": StringMeta("desc")})
self.serialized["takes"] = self.takes.to_dict()
self.serialized["defaults"] = OrderedDict({"in_attr": "default"})
self.serialized["description"] = "test_description"
self.serialized["tags"] = ()
self.serialized["writeable"] = True
self.serialized["label"] = ""
self.serialized["returns"] = MapMeta().to_dict()
def test_to_dict(self):
m = MethodModel("test_description")
m.set_takes(self.takes)
m.set_defaults(self.serialized["defaults"])
assert m.to_dict() == self.serialized
def test_from_dict(self):
m = MethodModel.from_dict(self.serialized)
assert m.takes.to_dict() == self.takes.to_dict()
assert m.defaults == self.serialized["defaults"]
assert m.tags == ()
assert m.writeable == True
assert m.label == ""
assert m.returns.to_dict() == MapMeta().to_dict()
class TestSerialization(unittest.TestCase):
def setUp(self):
self.serialized = OrderedDict()
self.serialized["typeid"] = "malcolm:core/Method:1.0"
self.takes = MapMeta()
self.takes.set_elements(OrderedDict({"in_attr": StringMeta("desc")}))
self.serialized["takes"] = self.takes.to_dict()
self.serialized["defaults"] = OrderedDict({"in_attr": "default"})
self.serialized["description"] = "test_description"
self.serialized["tags"] = []
self.serialized["writeable"] = True
self.serialized["label"] = ""
self.serialized["returns"] = MapMeta().to_dict()
def test_to_dict(self):
m = Method("test_description")
m.set_takes(self.takes)
m.set_defaults(self.serialized["defaults"])
self.assertEqual(m.to_dict(), self.serialized)
def test_from_dict(self):
m = Method.from_dict(self.serialized.copy())
self.assertEqual(m.takes.to_dict(), self.takes.to_dict())
self.assertEqual(m.defaults, self.serialized["defaults"])
self.assertEqual(m.tags, [])
self.assertEqual(m.writeable, True)
self.assertEqual(m.label, "")
self.assertEqual(m.returns.to_dict(), MapMeta().to_dict())
def test_recreate(self):
@method_takes(
"arg1",
StringMeta("Arg1"),
REQUIRED,
"extra",
StringMeta(),
REQUIRED,
)
def method1():
pass
@method_takes(
"arg8",
StringMeta("Arg8"),
REQUIRED,
"arg3",
StringMeta("Arg3"),
"32",
"arg4",
StringMeta("Arg4"),
OPTIONAL,
)
def method2():
pass
@method_takes(
"arg8",
StringMeta("Arg8"),
"2",
"arg3",
StringMeta("Arg3"),
"33",
)
def method3():
pass
m = MethodModel("Test")
m.recreate_from_others(
[method1.MethodModel, method2.MethodModel, method3.MethodModel],
without=["extra"])
itakes = MapMeta()
elements = OrderedDict()
elements["arg1"] = StringMeta("Arg1")
elements["arg8"] = StringMeta("Arg8")
elements["arg3"] = StringMeta("Arg3")
elements["arg4"] = StringMeta("Arg4")
itakes.set_elements(elements)
itakes.set_required(["arg1"])
defaults = OrderedDict()
defaults["arg8"] = "2"
defaults["arg3"] = "33"
assert m.takes.to_dict() == itakes.to_dict()
assert m.returns.to_dict() == MapMeta().to_dict()
assert m.defaults == defaults
def test_method_also_takes(self):
@method_takes(
"hello", StringMeta(), REQUIRED,
"hello2", BooleanMeta(), False)
class Thing(object):
pass
@method_also_takes(
"world", BooleanMeta(), REQUIRED,
"hello2", BooleanMeta(), True,
"default", StringMeta(), "nothing")
class Thing2(Thing):
pass
# Check original hasn't been modified
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
itakes.set_elements(ElementMap(elements))
itakes.set_required(["hello"])
defaults = OrderedDict()
defaults["hello2"] = False
self.assertEqual(Thing.MethodMeta.takes.to_dict(), itakes.to_dict())
self.assertEqual(Thing.MethodMeta.returns.to_dict(), MapMeta().to_dict())
self.assertEqual(Thing.MethodMeta.defaults, defaults)
# Check new one overrides/improves on original
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
elements["world"] = BooleanMeta()
elements["default"] = StringMeta()
itakes.set_elements(ElementMap(elements))
itakes.set_required(["hello", "world"])
defaults = OrderedDict()
defaults["hello2"] = True
defaults["default"] = "nothing"
self.assertEqual(Thing2.MethodMeta.takes.to_dict(), itakes.to_dict())
self.assertEqual(Thing2.MethodMeta.returns.to_dict(), MapMeta().to_dict())
self.assertEqual(Thing2.MethodMeta.defaults, defaults)
def test_method_also_takes(self):
@method_takes("hello", StringMeta(), REQUIRED, "hello2", BooleanMeta(),
False)
class Thing(object):
pass
@method_also_takes("world", BooleanMeta(), REQUIRED, "hello2",
BooleanMeta(), True, "default", StringMeta(),
"nothing")
class Thing2(Thing):
pass
# Check original hasn't been modified
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
itakes.set_elements(ElementMap(elements))
itakes.set_required(["hello"])
defaults = OrderedDict()
defaults["hello2"] = False
self.assertEqual(Thing.MethodMeta.takes.to_dict(), itakes.to_dict())
self.assertEqual(Thing.MethodMeta.returns.to_dict(),
MapMeta().to_dict())
self.assertEqual(Thing.MethodMeta.defaults, defaults)
# Check new one overrides/improves on original
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
elements["world"] = BooleanMeta()
elements["default"] = StringMeta()
itakes.set_elements(ElementMap(elements))
itakes.set_required(["hello", "world"])
defaults = OrderedDict()
defaults["hello2"] = True
defaults["default"] = "nothing"
self.assertEqual(Thing2.MethodMeta.takes.to_dict(), itakes.to_dict())
self.assertEqual(Thing2.MethodMeta.returns.to_dict(),
MapMeta().to_dict())
self.assertEqual(Thing2.MethodMeta.defaults, defaults)
def test_takes_given_defaults(self):
@method_takes("hello", StringMeta(), "Something")
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(ElementMap(OrderedDict(hello=StringMeta())))
self.assertEqual(say_hello.MethodMeta.takes.to_dict(), itakes.to_dict())
self.assertEqual(say_hello.MethodMeta.returns.to_dict(), MapMeta().to_dict())
self.assertEqual(say_hello.MethodMeta.defaults, {"hello": "Something"})
def test_takes_given_optional(self):
@takes("hello", StringMeta(), OPTIONAL)
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(OrderedDict(hello=StringMeta()))
self.assertEqual(say_hello.Method.takes.to_dict(), itakes.to_dict())
self.assertEqual(say_hello.Method.returns.to_dict(), MapMeta().to_dict())
self.assertEqual(say_hello.Method.defaults, {})
def test_takes_given_defaults(self):
@method_takes("hello", StringMeta(), "Something")
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(OrderedDict(hello=StringMeta()))
assert say_hello.MethodModel.takes.to_dict() == itakes.to_dict()
assert say_hello.MethodModel.returns.to_dict() == MapMeta().to_dict()
assert say_hello.MethodModel.defaults == {"hello": "Something"}
def test_method_also_takes(self):
@method_takes("hello", StringMeta(), REQUIRED, "hello2", BooleanMeta(),
False)
class Thing(object):
def __init__(self):
pass
@method_also_takes("world", BooleanMeta(), REQUIRED, "hello2",
BooleanMeta(), True, "default", StringMeta(),
"nothing")
class Thing2(Thing):
pass
# Check original hasn't been modified
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
itakes.set_elements(elements)
itakes.set_required(["hello"])
defaults = OrderedDict()
defaults["hello2"] = False
assert Thing.MethodModel.takes.to_dict() == itakes.to_dict()
assert Thing.MethodModel.returns.to_dict() == MapMeta().to_dict()
assert Thing.MethodModel.defaults == defaults
# Check new one overrides/improves on original
itakes = MapMeta()
elements = OrderedDict()
elements["hello"] = StringMeta()
elements["hello2"] = BooleanMeta()
elements["world"] = BooleanMeta()
elements["default"] = StringMeta()
itakes.set_elements(elements)
itakes.set_required(["hello", "world"])
defaults = OrderedDict()
defaults["hello2"] = True
defaults["default"] = "nothing"
assert Thing2.MethodModel.takes.to_dict() == itakes.to_dict()
assert Thing2.MethodModel.returns.to_dict() == MapMeta().to_dict()
assert Thing2.MethodModel.defaults == defaults
def test_takes_given_required(self):
@method_takes("hello", StringMeta(), REQUIRED)
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(OrderedDict(hello=StringMeta()))
itakes.set_required(["hello"])
assert say_hello.MethodModel.takes.to_dict() == itakes.to_dict()
assert say_hello.MethodModel.returns.to_dict() == MapMeta().to_dict()
assert say_hello.MethodModel.defaults == {}
def test_takes_given_defaults(self):
@takes("hello", StringMeta(), "Something")
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(OrderedDict(hello=StringMeta()))
self.assertEqual(say_hello.Method.takes.to_dict(), itakes.to_dict())
self.assertEqual(say_hello.Method.returns.to_dict(),
MapMeta().to_dict())
self.assertEqual(say_hello.Method.defaults, {"hello": "Something"})
def test_takes_given_required(self):
@takes("hello", StringMeta(), REQUIRED)
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(OrderedDict(hello=StringMeta()))
itakes.set_required(["hello"])
self.assertEqual(say_hello.Method.takes.to_dict(), itakes.to_dict())
self.assertEqual(say_hello.Method.returns.to_dict(),
MapMeta().to_dict())
self.assertEqual(say_hello.Method.defaults, {})
def test_returns_given_valid_sets(self):
@method_returns("hello", StringMeta(), REQUIRED)
def say_hello(ret):
"""Say hello"""
ret.hello = "Hello"
return ret
ireturns = MapMeta()
ireturns.set_elements(OrderedDict(hello=StringMeta()))
ireturns.set_required(["hello"])
assert say_hello.MethodModel.takes.to_dict() == MapMeta().to_dict()
assert say_hello.MethodModel.returns.to_dict() == ireturns.to_dict()
assert say_hello.MethodModel.defaults == {}
def test_takes_given_optional(self):
@method_takes("hello", StringMeta(), OPTIONAL)
def say_hello(params):
"""Say hello"""
print("Hello" + params.name)
itakes = MapMeta()
itakes.set_elements(ElementMap(OrderedDict(hello=StringMeta())))
self.assertEqual(say_hello.MethodMeta.takes.to_dict(),
itakes.to_dict())
self.assertEqual(say_hello.MethodMeta.returns.to_dict(),
MapMeta().to_dict())
self.assertEqual(say_hello.MethodMeta.defaults, {})
def test_returns_given_valid_sets(self):
@method_returns("hello", StringMeta(), REQUIRED)
def say_hello(ret):
"""Say hello"""
ret.hello = "Hello"
return ret
ireturns = MapMeta()
ireturns.set_elements(ElementMap(OrderedDict(hello=StringMeta())))
ireturns.set_required(["hello"])
self.assertEqual(say_hello.MethodMeta.takes.to_dict(), MapMeta().to_dict())
self.assertEqual(say_hello.MethodMeta.returns.to_dict(), ireturns.to_dict())
self.assertEqual(say_hello.MethodMeta.defaults, {})
class TestToDict(unittest.TestCase):
@patch('malcolm.core.attributemeta.AttributeMeta.to_dict')
def test_returns_dict(self, _):
e1 = MagicMock()
e1.name = "one"
a1 = OrderedDict()
e1.to_dict.return_value = a1
e2 = MagicMock()
e2.name = "two"
a2 = OrderedDict()
e2.to_dict.return_value = a2
self.meta_map = MapMeta("Test")
self.meta_map.add_element(e1, required=True)
self.meta_map.add_element(e2, required=False)
expected_elements_dict = OrderedDict()
expected_elements_dict['one'] = a1
expected_elements_dict['two'] = a2
expected_dict = OrderedDict()
expected_dict['elements'] = expected_elements_dict
expected_dict['required'] = ["one"]
response = self.meta_map.to_dict()
self.assertEqual(expected_dict, response)
@patch('malcolm.core.mapmeta.AttributeMeta')
def test_from_dict_deserialize(self, am_mock):
# prep dict
elements = OrderedDict()
elements["one"] = "e1"
elements["two"] = "e2"
required = ["one"]
d = dict(elements=elements, required=required)
# prep from_dict with AttributeMetas to return
am1 = MagicMock()
am1.name = "one"
am2 = MagicMock()
am2.name = "two"
am_mock.from_dict.side_effect = [am1, am2]
map_meta = MapMeta.from_dict("Test", d)
self.assertEqual(am_mock.from_dict.call_args_list, [
call("one", "e1"), call("two", "e2")])
self.assertEqual(map_meta.name, "Test")
self.assertEqual(map_meta.required, ["one"])
self.assertEqual(map_meta.elements, dict(one=am1, two=am2))
def test_returns_given_valid_sets(self):
@returns("hello", StringMeta(), REQUIRED)
def say_hello(ret):
"""Say hello"""
ret.hello = "Hello"
return ret
ireturns = MapMeta()
ireturns.set_elements(OrderedDict(hello=StringMeta()))
ireturns.set_required(["hello"])
self.assertEqual(say_hello.Method.takes.to_dict(), MapMeta().to_dict())
self.assertEqual(say_hello.Method.returns.to_dict(),
ireturns.to_dict())
self.assertEqual(say_hello.Method.defaults, {})
def test_recreate(self):
@method_takes(
"arg1", StringMeta("Arg1"), REQUIRED,
"extra", StringMeta(), REQUIRED,
)
def method1():
pass
@method_takes(
"arg8", StringMeta("Arg8"), REQUIRED,
"arg3", StringMeta("Arg3"), "32",
"arg4", StringMeta("Arg4"), OPTIONAL,
)
def method2():
pass
@method_takes(
"arg8", StringMeta("Arg8"), "2",
"arg3", StringMeta("Arg3"), "33",
)
def method3():
pass
m = MethodMeta("Test")
m.recreate_from_others([
method1.MethodMeta, method2.MethodMeta, method3.MethodMeta],
without=["extra"])
itakes = MapMeta()
elements = OrderedDict()
elements["arg1"] = StringMeta("Arg1")
elements["arg8"] = StringMeta("Arg8")
elements["arg3"] = StringMeta("Arg3")
elements["arg4"] = StringMeta("Arg4")
itakes.set_elements(ElementMap(elements))
itakes.set_required(["arg1"])
defaults = OrderedDict()
defaults["arg8"] = "2"
defaults["arg3"] = "33"
self.assertEqual(m.takes.to_dict(), itakes.to_dict())
self.assertEqual(m.returns.to_dict(), MapMeta().to_dict())
self.assertEqual(m.defaults, defaults)
def test_to_dict(self):
tm = MapMeta("desc")
tm.set_elements(dict(c1=self.sam))
tm.set_required(["c1"])
self.assertEqual(tm.to_dict(), self.serialized)
def test_to_dict(self):
tm = MapMeta("desc")
tm.set_elements(ElementMap(dict(c1=self.sam)))
tm.set_required(["c1"])
self.assertEqual(tm.to_dict(), self.serialized)
