def _prepare_map_meta(args, allow_defaults, defaults=None, elements=None, required=None):
# prepare some data structures that will be used for the takes MapMeta
if defaults is None:
defaults = OrderedDict()
if elements is None:
elements = OrderedDict()
if required is None:
required = []
for index in range(0, len(args), 3):
# pick out 3 arguments
name = args[index]
check_camel_case(name)
meta = args[index + 1]
default = args[index + 2]
# store them in the right structures
elements[name] = meta
if default is REQUIRED:
required.append(name)
elif default is not OPTIONAL:
assert allow_defaults, "Defaults not allowed in this structure"
defaults[name] = default
# Setup the takes MapMeta and attach it to the function's MethodMeta
meta = MapMeta()
meta.set_elements(ElementMap(elements))
meta.set_required(required)
return meta, defaults
def recreate_from_others(self, method_metas, without=None):
if without is None:
without = []
defaults = OrderedDict()
elements = OrderedDict()
required = []
# Populate the intermediate data structures
for method_meta in method_metas:
for element in method_meta.takes.elements:
if element not in without:
# Serialize it to copy it
serialized = method_meta.takes.elements[element].to_dict()
elements[element] = serialized
if element in method_meta.takes.required and element not in required:
required.append(element)
if element in method_meta.defaults:
defaults.pop(element, None)
defaults[element] = method_meta.defaults[element]
# TODO: what about returns?
# remove required args that are now defaulted
required = [r for r in required if r not in defaults]
# Update ourself from these structures
takes = MapMeta()
takes.set_elements(ElementMap(elements))
takes.set_required(required)
self.set_takes(takes)
self.set_defaults(defaults)
def _prepare_map_meta(args,
allow_defaults,
defaults=None,
elements=None,
required=None):
# prepare some data structures that will be used for the takes MapMeta
if defaults is None:
defaults = OrderedDict()
if elements is None:
elements = OrderedDict()
if required is None:
required = []
for index in range(0, len(args), 3):
# pick out 3 arguments
name = args[index]
check_camel_case(name)
meta = args[index + 1]
default = args[index + 2]
# store them in the right structures
elements[name] = meta
if default is REQUIRED:
required.append(name)
elif default is not OPTIONAL:
assert allow_defaults, \
"Defaults not allowed in this structure"
defaults[name] = default
# Setup the takes MapMeta and attach it to the function's MethodMeta
meta = MapMeta()
meta.set_elements(ElementMap(elements))
meta.set_required(required)
return meta, defaults
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/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())
def recreate_from_others(self, method_metas, without=None):
if without is None:
without = []
defaults = OrderedDict()
elements = OrderedDict()
required = []
# Populate the intermediate data structures
for method_meta in method_metas:
for element in method_meta.takes.elements:
if element not in without:
# Serialize it to copy it
serialized = method_meta.takes.elements[element].to_dict()
elements[element] = serialized
if element in method_meta.takes.required and \
element not in required:
required.append(element)
if element in method_meta.defaults:
defaults.pop(element, None)
defaults[element] = method_meta.defaults[element]
# TODO: what about returns?
# remove required args that are now defaulted
required = [r for r in required if r not in defaults]
# Update ourself from these structures
takes = MapMeta()
takes.set_elements(ElementMap(elements))
takes.set_required(required)
self.set_takes(takes)
self.set_defaults(defaults)
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_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_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_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):
@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_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(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, {})
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):
@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_to_dict(self):
s = StringMeta(description="a string")
meta = MapMeta()
elements = OrderedDict()
elements["b"] = s
elements["c"] = s
elements["d"] = NumberMeta("int32")
elements["e"] = s
meta.set_elements(elements)
m = Map(meta, {"b": "test", "d": 123, "e": "e"})
expected = OrderedDict()
expected["typeid"] = "malcolm:core/Map:1.0"
expected["b"] = "test"
expected["d"] = 123
expected["e"] = "e"
assert expected == m.to_dict()
class TestSetters(unittest.TestCase):
def setUp(self):
self.mm = MapMeta("description")
def test_values_set(self):
self.assertIsInstance(self.mm.elements, OrderedDict)
self.assertEqual(self.mm.elements, {})
self.assertEqual(self.mm.typeid, "malcolm:core/MapMeta:1.0")
self.assertEqual(self.mm.description, "description")
def test_set_elements(self):
els = dict(sam=StringArrayMeta())
self.mm.set_elements(els)
self.assertEqual(self.mm.elements, els)
def test_set_required(self):
req = ["ddd", "2"]
self.mm.set_required(req)
self.assertEqual(self.mm.required, req)
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_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)
class TestSetters(unittest.TestCase):
def setUp(self):
self.mm = MapMeta("description")
def test_values_set(self):
self.assertIsInstance(self.mm.elements, ElementMap)
self.assertEqual(len(self.mm.elements), 0)
self.assertEqual(self.mm.typeid, "malcolm:core/MapMeta:1.0")
self.assertEqual(self.mm.description, "description")
def test_set_elements(self):
els = ElementMap(dict(sam=StringArrayMeta()))
self.mm.set_elements(els)
self.assertEqual(self.mm.elements, els)
def test_set_required(self):
self.test_set_elements()
req = ["sam"]
self.mm.set_required(req)
self.assertEqual(self.mm.required, req)
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
class TestSetters(unittest.TestCase):
def setUp(self):
self.mm = MapMeta("description")
def test_values_set(self):
self.assertIsInstance(self.mm.elements, dict)
assert len(self.mm.elements) == 0
assert self.mm.typeid == "malcolm:core/MapMeta:1.0"
assert self.mm.description == "description"
def test_set_elements(self):
els = dict(sam=StringArrayMeta())
self.mm.set_elements(els)
assert self.mm.elements == els
def test_set_required(self):
self.test_set_elements()
req = ("sam",)
self.mm.set_required(req)
assert self.mm.required == req
class TestSetters(unittest.TestCase):
def setUp(self):
self.mm = MapMeta("description")
def test_values_set(self):
self.assertIsInstance(self.mm.elements, ElementMap)
self.assertEqual(len(self.mm.elements), 0)
self.assertEqual(self.mm.typeid, "malcolm:core/MapMeta:1.0")
self.assertEqual(self.mm.description, "description")
def test_set_elements(self):
els = ElementMap(dict(sam=StringArrayMeta()))
self.mm.set_elements(els)
self.assertEqual(self.mm.elements, els)
def test_set_required(self):
self.test_set_elements()
req = ["sam"]
self.mm.set_required(req)
self.assertEqual(self.mm.required, req)
def test_incomplete_return(self):
func = Mock(return_value={"output1": 2})
m = Method("test_description", writeable=True)
m.name = "test_method"
m.set_function(func)
s = StringMeta(description='desc')
args_meta = MapMeta()
args_meta.set_elements({"first": s, "second": s})
return_meta = MapMeta()
return_meta.set_elements({"output1": s, "output2": s})
return_meta.set_required(["output2"])
m.set_takes(args_meta)
m.set_returns(return_meta)
with self.assertRaises(KeyError):
m.call_function(dict(first=1, second=2))
call_arg1, call_arg2 = func.call_args_list[0][0]
self.assertEqual('1', call_arg1.first)
self.assertEqual('2', call_arg1.second)
self.assertEqual(args_meta, call_arg1.meta)
self.assertEqual(return_meta, call_arg2.meta)
def test_incomplete_return(self):
func = Mock(return_value={"output1": 2})
m = Method("test_description", writeable=True)
m.name = "test_method"
m.set_function(func)
s = StringMeta(description='desc')
args_meta = MapMeta()
args_meta.set_elements({"first": s, "second": s})
return_meta = MapMeta()
return_meta.set_elements({"output1": s, "output2": s})
return_meta.set_required(["output2"])
m.set_takes(args_meta)
m.set_returns(return_meta)
with self.assertRaises(KeyError):
m.call_function(dict(first=1, second=2))
call_arg1, call_arg2 = func.call_args_list[0][0]
self.assertEqual('1', call_arg1.first)
self.assertEqual('2', call_arg1.second)
self.assertEqual(args_meta, call_arg1.meta)
self.assertEqual(return_meta, call_arg2.meta)
class TestMap(unittest.TestCase):
def setUp(self):
n = NumberMeta(description='a number')
s = StringMeta(description="a string")
self.meta = MapMeta()
self.meta.set_elements({"a": s, "b": s})
self.meta.set_required(["a"])
self.nmeta = MapMeta()
self.nmeta.set_elements({"a": n, "b": n})
self.nmeta.set_required(["a"])
def test_init(self):
b_mock = MagicMock()
m = Map(self.meta, {"a": "test", "b": b_mock})
assert self.meta == m.meta
assert "test" == m.a
self.assertIs(str(b_mock), m.b)
assert "malcolm:core/Map:1.0" == m.typeid
def test_init_raises_on_bad_key(self):
with self.assertRaises(ValueError):
m = Map(self.meta, {"bad_key": MagicMock()})
def test_empty_init(self):
m = Map(self.meta, None)
assert self.meta == m.meta
with self.assertRaises(AttributeError):
m.a
def test_to_dict(self):
s = StringMeta(description="a string")
meta = MapMeta()
elements = OrderedDict()
elements["b"] = s
elements["c"] = s
elements["d"] = NumberMeta("int32")
elements["e"] = s
meta.set_elements(elements)
m = Map(meta, {"b": "test", "d": 123, "e": "e"})
expected = OrderedDict()
expected["typeid"] = "malcolm:core/Map:1.0"
expected["b"] = "test"
expected["d"] = 123
expected["e"] = "e"
assert expected == m.to_dict()
def test_from_dict(self):
map_meta = MagicMock()
map_meta.elements = {"a": Mock(), "b": Mock(), "c": Mock()}
map_meta.elements["a"].validate.return_value = 124
map_meta.elements["b"].validate.return_value = "Something"
map_meta.required = ["a"]
d = {"a": 123, "b": {"typeid": "mock_typeid"}}
m = Map(map_meta, d)
assert 124 == m.a
assert "Something" == m.b
def test_equals_maps(self):
self.meta.to_dict = MagicMock()
m1 = Map(self.meta, {"a": "test"})
m2 = Map(self.meta, {"a": "test2"})
assert not m1 == m2
assert m1 != m2
m2.a = "test"
assert m1 == m2
assert not m1 != m2
m2 = Map(self.meta, {"a": "test", "b": "test"})
assert not m1 == m2
m1["b"] = "test"
assert m1 == m2
s = StringMeta(description="a string")
meta2 = Meta()
meta2.elements = {"a": s, "b": s}
meta2.required = ["a"]
meta2.to_dict = self.meta.to_dict
m2 = Map(meta2, {"a": "test", "b": "test"})
assert m1 == m2
def test_equals_dicts(self):
m = Map(self.meta, {"a": "test"})
d = {"a": "test"}
assert m == d
assert not m != d
m["b"] = "test"
assert not m == d
assert m != d
d["b"] = "test2"
assert not m == d
assert m != d
d["b"] = "test"
assert m == d
assert not m != d
def test_contains(self):
m = Map(self.meta, {"a": "test"})
assert "a" in m
assert not "b" in m
assert not "__init__" in m
def test_get_item(self):
m = Map(self.meta, {"a": "test"})
assert "test" == m["a"]
m.a = "test_2"
assert "test_2" == m["a"]
def test_get_item_raises_if_no_key(self):
m = Map(self.meta, {"a": "test"})
with self.assertRaises(KeyError):
m["b"]
def test_get_item_fails_if_non_key(self):
m = Map(self.meta)
with self.assertRaises(KeyError):
m["__init__"]
def test_set_item(self):
m = Map(self.meta, {"a": 1})
a_mock = MagicMock()
b_mock = MagicMock()
m["a"] = a_mock
m["b"] = b_mock
assert str(a_mock) == m.a
assert str(b_mock) == m.b
def test_set_item_raises_invalid_key(self):
m = Map(self.meta)
with self.assertRaises(ValueError):
m["c"] = MagicMock()
def test_len(self):
m = Map(self.meta)
assert 0 == len(m)
m.a = 1
assert 1 == len(m)
m.b = 1
assert 2 == len(m)
def test_iter(self):
m = Map(self.meta, {"a": "x", "b": "y"})
assert {"a", "b"} == {x for x in m}
def test_update(self):
m = Map(self.nmeta, {"a": 1})
d = {"a": 2, "b": 2}
m.update(d)
assert 2 == m.a
assert 2 == m.b
def test_update_raises_on_invalid_key(self):
m = Map(self.nmeta, {"a": 1})
d = {"a": 2, "b": 2, "c": 2}
with self.assertRaises(ValueError):
m.update(d)
assert 1 == m.a
with self.assertRaises(AttributeError):
m.b
with self.assertRaises(AttributeError):
m.c
def test_clear(self):
m = Map(self.nmeta, {"a": 1})
m.clear()
with self.assertRaises(AttributeError):
m.a
def test_keys(self):
m = Map(self.nmeta, {"a": 1})
assert ["a"] == list(m.keys())
m.b = 1
assert {"a", "b"} == set(m.keys())
def test_values(self):
m = Map(self.nmeta, {"a": 1})
assert [1] == list(m.values())
m.b = 2
assert {1, 2} == set(m.values())
def test_items(self):
m = Map(self.nmeta, {"b": 2})
assert [("b", 2)] == list(m.items())
m.a = 1
assert {("a", 1), ("b", 2)} == set(m.items())
def test_repr(self):
m = Map(self.nmeta, {"b": 44})
r = repr(m)
assert r == "Map({'b': 44.0})"
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)
class TestMap(unittest.TestCase):
def setUp(self):
n = NumberMeta(description='a number')
s = StringMeta(description="a string")
self.meta = MapMeta()
self.meta.set_elements(ElementMap({"a": s, "b": s}))
self.meta.set_required(["a"])
self.nmeta = MapMeta()
self.nmeta.set_elements(ElementMap({"a": n, "b": n}))
self.nmeta.set_required(["a"])
def test_init(self):
b_mock = MagicMock()
m = Map(self.meta, {"a":"test", "b":b_mock})
self.assertEqual(self.meta, m.meta)
self.assertEqual("test", m.a)
self.assertIs(str(b_mock), m.b)
self.assertEqual("malcolm:core/Map:1.0", m.typeid)
def test_init_raises_on_bad_key(self):
with self.assertRaises(ValueError):
m = Map(self.meta, {"bad_key":MagicMock()})
def test_empty_init(self):
m = Map(self.meta, None)
self.assertEqual(self.meta, m.meta)
with self.assertRaises(AttributeError):
m.a
def test_to_dict(self):
a_mock = MagicMock()
s = StringMeta(description="a string")
meta = Meta()
meta.elements = OrderedDict()
meta.elements["b"] = s
meta.elements["c"] = s
meta.elements["d"] = NumberMeta("int32")
meta.elements["e"] = s
m = Map(meta, {"b":"test", "d":123, "e":"e"})
expected = OrderedDict()
expected["typeid"] = "malcolm:core/Map:1.0"
expected["b"] = "test"
expected["d"] = 123
expected["e"] = "e"
self.assertEquals(expected, m.to_dict())
def test_from_dict(self):
map_meta = MagicMock()
map_meta.elements = {"a": Mock(), "b": Mock(), "c": Mock()}
map_meta.elements["a"].validate.return_value = 124
map_meta.elements["b"].validate.return_value = "Something"
map_meta.required = ["a"]
d = {"a":123, "b":{"typeid":"mock_typeid"}}
m = Map(map_meta, d)
self.assertEquals(124, m.a)
self.assertEquals("Something", m.b)
def test_equals_maps(self):
self.meta.to_dict = MagicMock()
m1 = Map(self.meta, {"a":"test"})
m2 = Map(self.meta, {"a":"test2"})
self.assertFalse(m1 == m2)
self.assertTrue(m1 != m2)
m2.a = "test"
self.assertTrue(m1 == m2)
self.assertFalse(m1 != m2)
m2 = Map(self.meta, {"a":"test", "b":"test"})
self.assertFalse(m1 == m2)
m1["b"] = "test"
self.assertTrue(m1 == m2)
s = StringMeta(description="a string")
meta2 = Meta()
meta2.elements = {"a":s, "b":s}
meta2.required = ["a"]
meta2.to_dict = self.meta.to_dict
m2 = Map(meta2, {"a":"test", "b":"test"})
self.assertTrue(m1 == m2)
def test_equals_dicts(self):
m = Map(self.meta, {"a":"test"})
d = {"a":"test"}
self.assertTrue(m == d)
self.assertFalse(m != d)
m["b"] = "test"
self.assertFalse(m == d)
self.assertTrue(m != d)
d["b"] = "test2"
self.assertFalse(m == d)
self.assertTrue(m != d)
d["b"] = "test"
self.assertTrue(m == d)
self.assertFalse(m != d)
def test_contains(self):
m = Map(self.meta, {"a":"test"})
self.assertTrue("a" in m)
self.assertFalse("b" in m)
self.assertFalse("__init__" in m)
def test_get_item(self):
m = Map(self.meta, {"a":"test"})
self.assertEqual("test", m["a"])
m.a = "test_2"
self.assertEqual("test_2", m["a"])
def test_get_item_raises_if_no_key(self):
m = Map(self.meta, {"a":"test"})
with self.assertRaises(KeyError):
m["b"]
def test_get_item_fails_if_non_key(self):
m = Map(self.meta)
with self.assertRaises(KeyError):
m["__init__"]
def test_set_item(self):
m = Map(self.meta, {"a":1})
a_mock = MagicMock()
b_mock = MagicMock()
m["a"] = a_mock
m["b"] = b_mock
self.assertEqual(str(a_mock), m.a)
self.assertEqual(str(b_mock), m.b)
def test_set_item_raises_invalid_key(self):
m = Map(self.meta)
with self.assertRaises(ValueError):
m["c"] = MagicMock()
def test_len(self):
m = Map(self.meta)
self.assertEqual(0, len(m))
m.a = 1
self.assertEqual(1, len(m))
m.b = 1
self.assertEqual(2, len(m))
def test_iter(self):
m = Map(self.meta, {"a":"x", "b":"y"})
self.assertEqual({"a", "b"}, {x for x in m})
def test_update(self):
m = Map(self.nmeta, {"a":1})
d = {"a":2, "b":2}
m.update(d)
self.assertEqual(2, m.a)
self.assertEqual(2, m.b)
def test_update_raises_on_invalid_key(self):
m = Map(self.nmeta, {"a":1})
d = {"a":2, "b":2, "c":2}
with self.assertRaises(ValueError):
m.update(d)
self.assertEqual(1, m.a)
with self.assertRaises(AttributeError):
m.b
with self.assertRaises(AttributeError):
m.c
def test_clear(self):
m = Map(self.nmeta, {"a":1})
m.clear()
with self.assertRaises(AttributeError):
m.a
def test_keys(self):
m = Map(self.nmeta, {"a": 1})
self.assertEqual(["a"], list(m.keys()))
m.b = 1
self.assertEqual({"a", "b"}, set(m.keys()))
def test_values(self):
m = Map(self.nmeta, {"a":1})
self.assertEqual([1], list(m.values()))
m.b = 2
self.assertEqual({1, 2}, set(m.values()))
def test_items(self):
m = Map(self.nmeta, {"b":2})
self.assertEqual([("b", 2)], list(m.items()))
m.a = 1
self.assertEqual({("a", 1), ("b", 2)}, set(m.items()))
def test_repr(self):
m = Map(self.nmeta, {"b": 44})
r = repr(m)
self.assertEqual(r, "Map({'b': 44.0})")