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)