def testNoDisableMissing__run_option_hooks(self):
""" registration.run_option_hooks: runs the parsing methods for
registered plugins using option hooks; not disabled if missing
options in the parser.
"""
parser = self.MockParser()
parser.blocks = (('apps', (('sup', ('val1', 'val2')), )), )
# fake option registration for plugin
plugin = MockPlugin()
registration._registered.register(plugin.name, lambda: plugin,
{'option': True})
registration._option_hooks.register('apps_sup', lambda: plugin, {})
# run option hooks for plugin, check if it works
registration.run_option_hooks(parser, disable_missing=False)
self.assertTrue(hasattr(plugin, 'test__option'))
self.assertEqual(plugin.test__option,
[('sup', 'apps', ('val1', 'val2'))])
item = registration._registered.get(plugin.name)
self.assertIsNotNone(item)
plugin, props = item
self.assertFalse(props.get('disabled', False))
# run option hooks again for plugin using empty parser, confirm test
# plugin has not been disabled
registration.run_option_hooks(self.MockParser(), disable_missing=False)
self.assertFalse(props.get('disabled'))
def test__setup_sudo_access(self):
""" registration.setup_sudo_access: installs a sudo-based `run_root`
method onto the provided plugin.
"""
plugin = MockPlugin()
registration.setup_sudo_access(plugin)
# check if method was injected
method = getattr(plugin, 'run_root', None)
self.assertIsNotNone(method)
self.assertTrue(callable(method))
def setUp(self):
super(TestTaskRunner, self).setUp()
self.task = MockTask()
self.task.load()
self.pipe = MockPipe()
self.task_runner = daemon.TaskRunner(self.task, os.getpid(), self.pipe)
self.task_runner._rlock = self.MockLock()
# fake event plugin registration
self.plugin = MockPlugin()
self.plugin.needs_root = True
for event in ("task_start", "task_run", "task_end"):
registration._event_hooks[event] = [(self.plugin.name, lambda: self.plugin)]
registration._registered.register(self.plugin.name, lambda: self.plugin, {"event": True})
def test__run_event_hooks(self):
""" registration.run_event_hooks: runs the task event methods for
registered event plugins.
"""
plugin = MockPlugin()
# fake event registration for plugin
for event in ('task_start', 'task_run', 'task_end'):
registration._event_hooks[event] = [(plugin.name, lambda: plugin)]
# run event hooks for plugin, check if it works
registration.run_event_hooks(event, MockTask())
if event == 'task_start':
self.assertTrue(hasattr(plugin, 'test__task_started'))
elif event == 'task_run':
self.assertTrue(hasattr(plugin, 'test__task_ran'))
self.assertEqual(plugin.test__task_ran, 1)
elif event == 'task_end':
self.assertTrue(hasattr(plugin, 'test__task_ended'))
class TestTaskRunner(FocusTestCase):
class MockLock(object):
def acquire(self):
pass
def release(self):
pass
def setUp(self):
super(TestTaskRunner, self).setUp()
self.task = MockTask()
self.task.load()
self.pipe = MockPipe()
self.task_runner = daemon.TaskRunner(self.task, os.getpid(), self.pipe)
self.task_runner._rlock = self.MockLock()
# fake event plugin registration
self.plugin = MockPlugin()
self.plugin.needs_root = True
for event in ("task_start", "task_run", "task_end"):
registration._event_hooks[event] = [(self.plugin.name, lambda: self.plugin)]
registration._registered.register(self.plugin.name, lambda: self.plugin, {"event": True})
def tearDown(self):
self.plugin = None
self.task_runner = None
self.pipe = None
self.task = None
# unregister
registration._event_hooks = {}
registration._registered.clear()
super(TestTaskRunner, self).tearDown()
def testElapsedShutdown___run(self):
""" TaskRunner._run: Shuts down if task has elapsed.
"""
self.task_runner._task.elapsed = True
with self.assertRaises(SystemExit):
self.task_runner._run()
def test___setup_root_plugins(self):
""" TaskRunner._setup_root_plugins: installs root plugin methods.
"""
self.task_runner._setup_root_plugins()
# setup properly
method = getattr(self.plugin, "run_root", None)
self.assertIsNotNone(method)
self.assertTrue(callable(method))
# send command, received "OK" from server
self.pipe.send_bytes("OK") # fake response from command server
self.assertTrue(self.plugin.run_root("omg-llama"))
# verify packet that was sent to command server
self.assertEqual(self.pipe.recv_bytes(), "SHL\x80omg-llama")
# send again, this time with "FAIL" sent from server
self.pipe.send_bytes("FAIL")
self.assertFalse(self.plugin.run_root("omg-llama"))
self.assertEqual(self.pipe.recv_bytes(), "SHL\x80omg-llama")
# test TRM sentinel value received, shuts down this process
self.pipe.send_bytes("TRM")
with self.assertRaises(SystemExit):
self.plugin.run_root("omg-llama")
def testTaskEnd___run_events(self):
""" TaskRunner._run_events: runs task_end events.
"""
self.task_runner._run_events(shutdown=True)
self.assertTrue(hasattr(self.plugin, "test__task_started"))
self.assertTrue(hasattr(self.plugin, "test__task_ended"))
self.assertFalse(hasattr(self.plugin, "test__task_ran"))
def testTaskRun___run_events(self):
""" TaskRunner._run_events: runs task_run events.
"""
self.task_runner._run_events(shutdown=False)
self.assertTrue(hasattr(self.plugin, "test__task_started"))
self.assertTrue(hasattr(self.plugin, "test__task_ran"))
self.assertFalse(hasattr(self.plugin, "test__task_ended"))
# test running non-shutdown multiple times, should call task_run
# multiple times
for i in range(10):
self.assertEqual(self.plugin.test__task_ran, i + 1)
self.task_runner._run_events(shutdown=False)
def testSkipHooks__shutdown(self):
""" TaskRunner.shutdown: shuts down process, skipping event hooks.
"""
with self.assertRaises(SystemExit):
self.task_runner.shutdown(skip_hooks=True)
# check if end hooks were not called
self.assertFalse(hasattr(self.plugin, "test__task_ended"))
_check_pipe_shutdown(self, self.pipe)
self.assertFalse(self.task.active)
def testNoSkipHooks__shutdown(self):
""" TaskRunner.shutdown: shuts down process, without skipping event
hooks.
"""
with self.assertRaises(SystemExit):
self.task_runner.shutdown(skip_hooks=False)
# check if end hooks were called
self.assertTrue(hasattr(self.plugin, "test__task_ended"))
_check_pipe_shutdown(self, self.pipe)
self.assertFalse(self.task.active)