def test_publish_controller(self):
class PublishController(Controller):
published = []
def on_hook(self, hook):
if isinstance(hook, ProcessPublishHook):
hook(self.do_publish)
@add_call_types
def do_publish(self, published):
# type: (APublished) -> None
self.published = published
class UnpublishableController(Controller):
def on_hook(self, hook):
if isinstance(hook, ProcessStartHook):
hook(self.on_start)
def on_start(self):
return UnpublishedInfo(self.mri)
c = PublishController("mri")
self.o.add_controller(c)
assert c.published == ["mri"]
self.o.add_controller(Controller(mri="mri2"))
assert c.published == ["mri", "mri2"]
self.o.add_controller(UnpublishableController("mri3"))
assert c.published == ["mri", "mri2"]
def test_publish_controller(self):
c = PublishController("mri")
self.o.add_controller(c)
assert c.published == ["mri"]
self.o.add_controller(Controller(mri="mri2"))
assert c.published == ["mri", "mri2"]
self.o.add_controller(UnpublishableController("mri3"))
assert c.published == ["mri", "mri2"]
def setUp(self):
self.c = Controller('block', MagicMock())
self.b = self.c.block
class TestController(unittest.TestCase):
maxDiff = None
def setUp(self):
self.c = Controller('block', MagicMock())
self.b = self.c.block
def test_init(self):
self.c.process.add_block.assert_called_once_with(self.b)
self.assertEqual({}, self.c.parts)
self.assertEqual(self.b["state"].meta.typeid,
"malcolm:core/ChoiceMeta:1.0")
self.assertEqual(self.b.state, "Disabled")
self.assertEqual(self.b["status"].meta.typeid,
"malcolm:core/StringMeta:1.0")
self.assertEqual(self.b.status, "Disabled")
self.assertEqual(self.b["busy"].meta.typeid,
"malcolm:core/BooleanMeta:1.0")
self.assertEqual(self.b.busy, False)
def test_set_writeable_methods(self):
m = MagicMock()
m.name = "configure"
self.c.register_method_writeable(m, "Ready")
self.assertEqual(self.c.methods_writeable['Ready'][m], True)
def test_run_hook(self):
hook = MagicMock()
func = MagicMock()
func.return_value = {"foo": "bar"}
task = MagicMock()
part = MagicMock()
part_tasks = {part: task}
hook_queue = self.c.process.create_queue.return_value
hook_queue.get.return_value = (func, func.return_value)
hook.find_func_tasks.return_value = {func: task}
hook.make_return_table.return_value.endpoints = ["name", "foo"]
self.c.hook_names = {hook: "test_hook"}
self.c.parts = {"test_part": part}
result = self.c.run_hook(hook, part_tasks)
self.assertEquals(hook.make_return_table.return_value, result)
result.append.assert_called_once_with(["test_part", "bar"])
def test_run_hook_table(self):
hook = MagicMock()
func = MagicMock()
func.return_value = {"foo": ["bar", "bat", "baz"], "two": 2}
func2 = MagicMock()
func2.return_value = {"foo": ["bar2", "bat2"], "two": 3}
task = MagicMock()
task2 = MagicMock()
part = MagicMock()
part2 = MagicMock()
part_tasks = {part: task, part2: task2}
hook_queue = self.c.process.create_queue.return_value
hook_queue.get.side_effect = [(func, func.return_value),
(func2, func2.return_value)]
hook.find_func_tasks.return_value = {func: task, func2: task2}
return_table = hook.make_return_table.return_value
return_table.endpoints = ["name", "foo", "two"]
return_table.meta.elements = dict(
name=StringArrayMeta(),
foo=StringArrayMeta(tags=["hook:return_array"]),
two=NumberArrayMeta("int32"))
self.c.hook_names = {hook: "test_hook"}
self.c.parts = {"test_part": part, "part2": part2}
result = self.c.run_hook(hook, part_tasks)
self.assertEquals(hook.make_return_table.return_value, result)
result.append.assert_has_calls([
call(["test_part", "bar", 2]),
call(["test_part", "bat", 2]),
call(["test_part", "baz", 2]),
call(["part2", "bar2", 3]),
call(["part2", "bat2", 3]),
],
any_order=True)
def test_run_hook_raises(self):
hook = MagicMock()
func = MagicMock(side_effect=Exception("Test Exception"))
task = MagicMock()
part = MagicMock()
hook_tasks = {func: task}
part_tasks = {part: task}
hook_queue = self.c.process.create_queue.return_value
hook_queue.get.return_value = (func, func.side_effect)
hook.find_func_tasks.return_value = {func: task}
self.c.test_hook = hook
self.c.hook_names = {hook: "test_hook"}
self.c.parts = {"test_part": part}
with self.assertRaises(Exception) as cm:
self.c.run_hook(hook, part_tasks)
self.assertIs(func.side_effect, cm.exception)
def setUp(self):
params = Controller.MethodMeta.prepare_input_map(mri="mri1")
self.c = Controller(MagicMock(), {}, params)
self.b = self.c.block
class TestController(unittest.TestCase):
maxDiff = None
def setUp(self):
params = Controller.MethodMeta.prepare_input_map(mri="mri1")
self.c = Controller(MagicMock(), {}, params)
self.b = self.c.block
def test_init(self):
self.c.process.add_block.assert_called_once_with(self.b, self.c)
self.assertEqual({}, self.c.parts)
self.assertEqual(
self.b["state"].meta.typeid, "malcolm:core/ChoiceMeta:1.0")
self.assertEqual(self.b.state, "Disabled")
self.assertEqual(
self.b["status"].meta.typeid, "malcolm:core/StringMeta:1.0")
self.assertEqual(self.b.status, "Disabled")
self.assertEqual(
self.b["busy"].meta.typeid, "malcolm:core/BooleanMeta:1.0")
self.assertEqual(self.b.busy, False)
def test_set_writeable_methods(self):
m = MagicMock()
m.name = "configure"
self.c.register_child_writeable(m, "Ready")
self.assertEqual(self.c.children_writeable['Ready'][m], True)
def make_part_tasks(self, hook, func):
task = MagicMock()
func_name = "configure"
part = MagicMock()
part.name = "test_part"
part.method_metas = {}
setattr(part, func_name, func)
part_tasks = {part: task}
hook_queue = self.c.process.create_queue.return_value
def side_effect():
task_return = task.define_spawn_function.call_args[0][0]
task_return()
return hook_queue.put.call_args[0][0]
hook_queue.get.side_effect = side_effect
hook.find_hooked_functions.return_value = {part: func_name}
self.c.hook_names = {hook: "test_hook"}
return part_tasks
def test_run_hook(self):
hook = MagicMock()
func = MagicMock()
func.return_value = {"foo": "bar"}
part_tasks = self.make_part_tasks(hook, func)
result = self.c.run_hook(hook, part_tasks)
self.assertEquals(result, dict(test_part=dict(foo="bar")))
def test_run_hook_raises(self):
hook = MagicMock()
func = MagicMock(side_effect=Exception("Test Exception"))
part_tasks = self.make_part_tasks(hook, func)
with self.assertRaises(Exception) as cm:
self.c.run_hook(hook, part_tasks)
self.assertIs(func.side_effect, cm.exception)
def setUp(self):
params = Controller.MethodMeta.prepare_input_map(mri="mri1")
self.c = Controller(MagicMock(), {}, params)
self.b = self.c.block
class TestController(unittest.TestCase):
maxDiff = None
def setUp(self):
params = Controller.MethodMeta.prepare_input_map(mri="mri1")
self.c = Controller(MagicMock(), {}, params)
self.b = self.c.block
def test_init(self):
self.c.process.add_block.assert_called_once_with(self.b, self.c)
self.assertEqual({}, self.c.parts)
self.assertEqual(self.b["state"].meta.typeid,
"malcolm:core/ChoiceMeta:1.0")
self.assertEqual(self.b.state, "Disabled")
self.assertEqual(self.b["status"].meta.typeid,
"malcolm:core/StringMeta:1.0")
self.assertEqual(self.b.status, "Disabled")
self.assertEqual(self.b["busy"].meta.typeid,
"malcolm:core/BooleanMeta:1.0")
self.assertEqual(self.b.busy, False)
def test_set_writeable_methods(self):
m = MagicMock()
m.name = "configure"
self.c.register_child_writeable(m, "Ready")
self.assertEqual(self.c.children_writeable['Ready'][m], True)
def make_part_tasks(self, hook, func):
task = MagicMock()
func_name = "configure"
part = MagicMock()
part.name = "test_part"
part.method_metas = {}
setattr(part, func_name, func)
part_tasks = {part: task}
hook_queue = self.c.process.create_queue.return_value
def side_effect():
task_return = task.define_spawn_function.call_args[0][0]
task_return()
return hook_queue.put.call_args[0][0]
hook_queue.get.side_effect = side_effect
hook.find_hooked_functions.return_value = {part: func_name}
self.c.hook_names = {hook: "test_hook"}
return part_tasks
def test_run_hook(self):
hook = MagicMock()
func = MagicMock()
func.return_value = {"foo": "bar"}
part_tasks = self.make_part_tasks(hook, func)
result = self.c.run_hook(hook, part_tasks)
self.assertEquals(result, dict(test_part=dict(foo="bar")))
def test_run_hook_raises(self):
hook = MagicMock()
func = MagicMock(side_effect=Exception("Test Exception"))
part_tasks = self.make_part_tasks(hook, func)
with self.assertRaises(Exception) as cm:
self.c.run_hook(hook, part_tasks)
self.assertIs(func.side_effect, cm.exception)
