def setUp(self):
self.callback_result = 0
self.callback_value = ''
meta = VMeta("meta for unit tests")
self.block = MagicMock()
self.proc = MagicMock(q=queue.Queue())
self.proc.create_queue = MagicMock(side_effect=queue.Queue)
self.attr = Attribute(meta)
self.attr.set_parent(self.block, "testAttr")
self.attr2 = Attribute(meta)
self.attr2.set_parent(self.block, "testAttr2")
self.method = Method("method for unit tests")
self.method.set_parent(self.block, "testFunc")
self.method2 = Method("method for unit tests")
self.method2.set_parent(self.block, "testFunc")
self.bad_called_back = False
def test_not_writeable_stops_call(self):
m = Method("test_description")
m.set_function(Mock())
m.set_writeable(False)
with self.assertRaises(
ValueError, msg="Cannot call a method that is not writeable"):
m()
def test_defaults(self):
func = Mock(return_value={"first_out": "test"})
m = Method("test_method", "test_description")
arg_meta = Mock()
arg_meta.elements = {"first": Mock(), "second": Mock()}
m.set_function_takes(arg_meta, {"second": "default"})
m.set_function(func)
self.assertEquals({"first_out": "test"}, m(first="test"))
func.assert_called_with({"first": "test", "second": "default"})
def test_simple_function(self):
func = Mock(return_value={"first_out": "test"})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
args_meta.elements = {"first": Mock()}
m.set_function_takes(args_meta)
result = m(first="test")
self.assertEquals({"first_out": "test"}, result)
func.assert_called_with({"first": "test"})
def create_methods(self):
"""Create a Method wrapper for say_hello and return it"""
method = Method("say_hello", "says hello")
method.set_function(self.say_hello)
takes = MapMeta("takes")
takes.add_element(StringMeta("name", "a name"))
method.set_function_takes(takes)
returns = MapMeta("returns")
returns.add_element(StringMeta("greeting", "a greeting"))
method.set_function_returns(returns)
yield method
def test_handle_request_error(self):
func = MagicMock()
func.side_effect = ValueError("Test error")
m = Method("test_method", "test_description")
m.set_function(func)
m.takes = MagicMock()
m.returns = MagicMock()
request = MagicMock()
m.handle_request(request)
request.respond_with_error.assert_called_once_with(
"Method test_method raised an error: Test error")
def test_handle_request(self, call_function_mock):
call_function_mock.return_value = {"output": 1}
m = Method("test_description")
m.set_logger_name("mname")
request = Mock(id=(123, Mock()),
type="Post",
parameters={"first": 2},
respond_with_return=Mock())
response = m.get_response(request)
call_function_mock.assert_called_with({"first": 2})
self.assertEquals({"output": 1}, response.value)
def test_required(self):
func = Mock(return_value={"first_out": "test"})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
args_meta.elements = {"first": Mock(), "second": Mock()}
args_meta.required = ["first"]
m.set_function_takes(args_meta, {"first": "default"})
self.assertEquals({"first_out": "test"}, m())
func.assert_called_with({"first": "default"})
m.set_function_takes(args_meta, {"second": "default"})
self.assertRaises(ValueError, m)
def test_get_response_raises(self):
func = MagicMock()
func.side_effect = ValueError("Test error")
m = Method("test_description")
m.set_parent(Mock(), "test_method")
m.set_function(func)
m.takes = MagicMock()
m.returns = MagicMock()
request = MagicMock()
response = m.get_response(request)
self.assertEquals("malcolm:core/Error:1.0", response.typeid)
self.assertEquals("Method test_method raised an error: Test error",
response.message)
def test_call_calls_call_function(self):
m = Method("test_description")
call_func_mock = MagicMock()
call_func_mock.return_value = {"output": 2}
m.call_function = call_func_mock
func = Mock(return_value={"first_out": "test"})
m.set_function(func)
args_meta = Mock(spec=MapMeta)
args_meta.elements = {"first": Mock()}
m.set_takes(args_meta)
response = m(first="test")
call_func_mock.assert_called_once_with(dict(first="test"))
self.assertEqual(response, {"output": 2})
def test_incomplete_return(self):
func = Mock(return_value={"output1": 2})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
args_meta.elements = {"first": Mock(), "second": Mock()}
return_meta = Mock()
return_meta.elements = {"output1": Mock(), "output2": Mock()}
validator = Mock(return_value=True)
return_meta.elements["output1"].validate = validator
return_meta.elements["output2"].validate = validator
m.set_function_takes(args_meta)
m.set_function_returns(return_meta)
self.assertRaises(ValueError, m, first=1, second=2)
func.assert_called_with({"first": 1, "second": 2})
def test_handle_request(self):
func = Mock(return_value={"output": 1})
args_meta = Mock(elements={"first": Mock()})
return_meta = Mock(elements={"output": Mock()})
m = Method("test_method", "test_description")
m.set_function(func)
m.set_function_takes(args_meta)
m.set_function_returns(return_meta)
request = Mock(id=(123, Mock()),
type="Post",
parameters={"first": 2},
respond_with_return=Mock())
m.handle_request(request)
func.assert_called_with({"first": 2})
request.respond_with_return.assert_called_with({"output": 1})
def test_get_response_no_parameters(self):
m = Method("test_description")
m.set_logger_name("mname")
call_func_mock = MagicMock()
m.call_function = call_func_mock
func = Mock(return_value={"first_out": "test"})
m.set_function(func)
args_meta = Mock(spec=MapMeta)
args_meta.elements = {"first": Mock()}
m.set_takes(args_meta)
request = MagicMock()
del request.parameters # Make sure mock doesn't have `parameters`
m.get_response(request)
call_func_mock.assert_called_once_with(dict())
def test_defaults(self):
func = Mock(return_value={"first_out": "test"})
m = Method("test_description", writeable=True)
m.set_parent(Mock(), "test_method")
s = StringMeta(description='desc')
args_meta = MapMeta()
args_meta.elements = {"first": s, "second": s}
m.set_takes(args_meta)
m.set_defaults({"second": "default"})
m.set_function(func)
self.assertEquals({"first_out": "test"},
m.call_function(dict(first="test")))
call_arg = func.call_args[0][0]
self.assertEqual("test", call_arg.first)
self.assertEqual("default", call_arg.second)
self.assertEqual(args_meta, call_arg.meta)
def test_invalid_return(self):
func = Mock(return_value={"output1": 2, "output2": 4})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
args_meta.elements = {"first": Mock(), "second": Mock()}
return_meta = Mock()
return_meta.elements = {"output1": Mock(), "output2": Mock()}
validator1 = Mock(return_value=True)
validator2 = Mock(side_effect=TypeError("Fake type error"))
return_meta.elements["output1"].validate = validator1
return_meta.elements["output2"].validate = validator2
m.set_function_takes(args_meta)
m.set_function_returns(return_meta)
self.assertRaises(TypeError, m, first=1, second=2)
func.assert_called_with({"first": 1, "second": 2})
validator2.assert_called_with(4)
def test_replace_children(self):
b = Block()
b.name = "blockname"
b.methods["m1"] = 2
b.attributes["a1"] = 3
setattr(b, "m1", 2)
setattr(b, "a1", 3)
attr_meta = StringMeta(description="desc")
attr = Attribute(attr_meta)
b.add_attribute('attr', attr)
method = Method(description="desc")
b.add_method('method', method)
b.on_changed = MagicMock(wrap=b.on_changed)
b.replace_children({'attr': attr, 'method': method})
self.assertEqual(b.attributes, dict(attr=attr))
self.assertEqual(b.methods, dict(method=method))
b.on_changed.assert_called_once_with([[], b.to_dict()], True)
self.assertFalse(hasattr(b, "m1"))
self.assertFalse(hasattr(b, "a1"))
def test_valid_return(self):
func = Mock(return_value={"output1": 2, "output2": 4})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
args_meta.elements = {"first": Mock(), "second": Mock()}
args_meta.required = ["first", "second"]
return_meta = Mock()
return_meta.elements = {"output1": Mock(), "output2": Mock()}
validator1 = Mock(return_value=True)
validator2 = Mock(return_value=True)
return_meta.elements["output1"].validate = validator1
return_meta.elements["output2"].validate = validator2
m.set_function_takes(args_meta)
m.set_function_returns(return_meta)
self.assertEquals({"output1": 2, "output2": 4}, m(first=1, second=2))
func.assert_called_with({"first": 1, "second": 2})
validator1.assert_called_with(2)
validator2.assert_called_with(4)
def test_to_dict_serialization(self):
func = Mock(return_value={"out": "dummy"})
defaults = {"in_attr": "default"}
args_meta = Mock(
elements={"first": Mock()},
to_dict=Mock(return_value=OrderedDict({"dict": "args"})))
return_meta = Mock(
elements={"out": Mock()},
to_dict=Mock(return_value=OrderedDict({"dict": "return"})))
m = Method("test_method", "test_description")
m.set_function(func)
m.set_function_takes(args_meta, defaults)
m.set_function_returns(return_meta)
expected = OrderedDict()
expected["description"] = "test_description"
expected["takes"] = OrderedDict({"dict": "args"})
expected["defaults"] = OrderedDict({"in_attr": "default"})
expected["returns"] = OrderedDict({"dict": "return"})
self.assertEquals(expected, m.to_dict())
def test_positional_args(self):
func = Mock(return_value={"output": 2})
m = Method("test_method", "test_description")
m.set_function(func)
args_meta = Mock()
validator = Mock(return_value=True)
args_meta.elements = OrderedDict()
args_meta.elements["first"] = Mock(validate=validator)
args_meta.elements["second"] = Mock(validate=validator)
args_meta.elements["third"] = Mock(validate=validator)
args_meta.elements["fourth"] = Mock(validate=validator)
args_meta.required = ["first", "third"]
m.set_function_takes(args_meta)
self.assertEquals({"output": 2}, m(2, 3, third=1, fourth=4))
func.assert_called_with({
"first": 2,
"second": 3,
"third": 1,
"fourth": 4
})
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_call_with_positional_args(self):
func = Mock(return_value={"output": 2})
m = Method("test_description")
call_func_mock = MagicMock()
m.call_function = call_func_mock
m.set_function(func)
args_meta = Mock(spec=MapMeta)
validator = Mock(return_value=True)
args_meta.elements = OrderedDict()
args_meta.elements["first"] = Mock(validate=validator)
args_meta.elements["second"] = Mock(validate=validator)
args_meta.elements["third"] = Mock(validate=validator)
args_meta.elements["fourth"] = Mock(validate=validator)
args_meta.required = ["first", "third"]
m.set_takes(args_meta)
m(2, 3, third=1, fourth=4)
call_func_mock.assert_called_once_with({
'second': 3,
'fourth': 4,
'third': 1,
'first': 2
})
def test_init(self):
m = Method("test_description")
self.assertEquals("test_description", m.description)
self.assertEquals("malcolm:core/Method:1.0", m.typeid)
self.assertEquals("", m.label)
def test_init(self):
m = Method("test_method", "test_description")
self.assertEquals("test_method", m.name)
self.assertEquals("test_description", m.description)
def test_set_label(self):
m = Method("test_description")
m.on_changed = Mock(wrap=m.on_changed)
m.set_label("new_label")
self.assertEquals("new_label", m.label)
m.on_changed.assert_called_once_with([["label"], "new_label"], True)
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)
