class TestTaskProcess(FocusTestCase): def setUp(self): super(TestTaskProcess, self).setUp() self.task = MockTask() self.task.load() self.pipe = MockPipe() self.process = daemon.TaskProcess(self.task, os.getpid(), self.pipe) def tearDown(self): self.process = None self.pipe = None self.task = None super(TestTaskProcess, self).tearDown() def testExited__running(self): """ TaskProcess.running (property): process has exited: not running. """ self.process._exited = True self.assertFalse(self.process.running) def testParentExited__running(self): """ TaskProcess.running (property): parent has exited: not running. """ self.process._ppid = 999999 # set parent pid invalid self.assertFalse(self.process.running) def test__shutdown(self): """ TaskProcess.shutdown: process is shutdown. """ with self.assertRaises(SystemExit): self.process.shutdown() _check_pipe_shutdown(self, self.pipe) self.assertFalse(self.task.active)
class TestCommandServer(FocusTestCase): def setUp(self): super(TestCommandServer, self).setUp() self.task = MockTask() self.task.load() self.pipe = MockPipe() self.command_server = daemon.CommandServer(self.task, os.getpid(), self.pipe) def tearDown(self): self.plugin = None self.task_runner = None self.pipe = None self.task = None super(TestCommandServer, self).tearDown() def test___process_commands(self): """ CommandServer._process_commands: processes received commands. """ # test existing command received self.pipe.send_bytes("SHL\x80ls") # run `ls` shell command self.assertTrue(self.command_server._process_commands()) self.assertEqual(self.pipe.recv_bytes(), "OK") # sent 'OK' response # test non-existent command received self.pipe.send_bytes("SHL\x80non-exist") self.assertTrue(self.command_server._process_commands()) self.assertEqual(self.pipe.recv_bytes(), "FAIL") # send 'FAIL' resp. # test TRM sentinel value received self.pipe.send_bytes("TRM") self.assertFalse(self.command_server._process_commands())
def testCallNotifyFunc___notify(self): """ Notify._notify: calls function defined by notify_func. """ test_task = MockTask() test_task.start('Test-Task') ret_items = [] def _check_func(task, message): ret_items.append((task, message)) self.plugin.notify_func = _check_func self.plugin._notify(test_task, 'message-here') for item in ret_items: self.assertEqual(item, ('Focus ({0})'.format(test_task.name), 'message-here'))
def testCallNotifyFunc___notify(self): """ Notify._notify: calls function defined by notify_func. """ test_task = MockTask() test_task.start('Test-Task') ret_items = [] def _check_func(task, message): ret_items.append((task, message)) self.plugin.notify_func = _check_func self.plugin._notify(test_task, 'message-here') for item in ret_items: self.assertEqual( item, ('Focus ({0})'.format(test_task.name), 'message-here'))
def setUp(self): super(TestFocusd, self).setUp() self.task = MockTask() self.pid_file = os.path.join(self.task.base_dir, ".focusd.pid") open(self.pid_file, "w", 0).write("99999999\n") self.task.load() self.pipe = MockPipe() self.focusd = daemon.Focusd(self.task) self.focusd._pipe = self.pipe self.focusd._command_server = MockTaskProcess() self.focusd._task_runner = MockTaskProcess()
def setUp(self): super(TestSiteBlock, self).setUp() self.setup_dir() self.task = MockTask(base_dir=self.test_dir, make_task_dir=True) self.plugin = plugins.SiteBlock() self.mock_run_root(self.plugin) self.plugin.hosts_file = os.path.join(self.task.task_dir, 'focus_test_hosts') open(self.plugin.hosts_file, 'w').write(_HOST_FILE_DATA) self.backup_hosts_file = os.path.join(self.task.task_dir, '.hosts.bak')
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 TestFocusd(FocusTestCase): def setUp(self): super(TestFocusd, self).setUp() self.task = MockTask() self.pid_file = os.path.join(self.task.base_dir, ".focusd.pid") open(self.pid_file, "w", 0).write("99999999\n") self.task.load() self.pipe = MockPipe() self.focusd = daemon.Focusd(self.task) self.focusd._pipe = self.pipe self.focusd._command_server = MockTaskProcess() self.focusd._task_runner = MockTaskProcess() def tearDown(self): self.focusd = None self.task = None self.pipe = None self.clean_paths(self.pid_file) super(TestFocusd, self).tearDown() def _setup_for_run(self): # overwrite methods to test if they were called def _drop_privs(self): self.test__dropped_privs = True self.focusd._drop_privs = types.MethodType(_drop_privs, self.focusd) def _shutdown(self): self.test__shutdown = True self.focusd.shutdown = types.MethodType(_shutdown, self.focusd) # inject no-op method, we don't want signal handling while testing self.focusd._reg_sighandlers = types.MethodType(lambda self: None, self.focusd) def test___drop_privs(self): """ Focusd._drop_privs: privileges are dropped to current user and environment variables are updated. """ self.focusd._drop_privs() self.assertEqual(self.task.owner, os.getuid()) # env vars updated info = pwd.getpwuid(self.task.owner) for k in ("USER", "USERNAME", "SHELL", "HOME"): if k in os.environ: v = os.environ[k] if k in ("USER", "USERNAME"): self.assertEqual(v, info.pw_name) elif k == "SHELL": self.assertEqual(v, info.pw_shell) elif k == "HOME": self.assertEqual(v, info.pw_dir) # some env vars removed self.assertEqual([], [k for k in os.environ.keys() if k.startswith("SUDO_") or k == "LOGNAME"]) # proper umask set try: old_mask = os.umask(022) os.umask(old_mask) self.assertEqual(old_mask, 022) except OSError: pass def test__shutdown(self): """ Focusd.shutdown: task runner process is shutdown. """ self.focusd._exited = False self.focusd._task_runner.start() self.focusd.shutdown() _check_pipe_shutdown(self, self.pipe) self.assertFalse(self.task.active) def testStartCmdServer__run(self): """ Focusd.run: run with command server started. """ self._setup_for_run() self.focusd._exited = True # fake it, so event loop stops self.focusd.run(start_command_srv=True) # all called self.assertTrue(hasattr(self.focusd._command_server, "test__started")) self.assertTrue(hasattr(self.focusd, "test__dropped_privs")) self.assertTrue(hasattr(self.focusd._task_runner, "test__started")) self.assertTrue(hasattr(self.focusd, "test__shutdown")) def testWithoutStartCmdServer__run(self): """ Focusd.run: run without command server started. """ self._setup_for_run() self.focusd._exited = True # fake it, so event loop stops self.focusd.run(start_command_srv=False) # not called self.assertFalse(hasattr(self.focusd._command_server, "test__started")) self.assertFalse(hasattr(self.focusd, "test__dropped_privs")) # called self.assertTrue(hasattr(self.focusd._task_runner, "test__started")) self.assertTrue(hasattr(self.focusd, "test__shutdown")) def testPidFileExistTaskActive__running(self): """ Focusd.running (property): pidfile exists and task active: running. """ self.assertTrue(self.focusd.running) def testNoPidFileExist__running(self): """ Focusd.running (property): no pid file exists: not running. """ self.clean_paths(self.pid_file) self.assertFalse(self.focusd.running) def testTaskNotActive__running(self): """ Focusd.running (property): no active task: not running. """ self.task._loaded = False self.assertFalse(self.focusd.running) def testExited__running(self): """ Focusd.running (property): focusd has exited: not running. """ self.focusd._exited = True self.assertFalse(self.focusd.running)
def setUp(self): super(TestCommandServer, self).setUp() self.task = MockTask() self.task.load() self.pipe = MockPipe() self.command_server = daemon.CommandServer(self.task, os.getpid(), self.pipe)
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)
def setUp(self): super(TestTaskProcess, self).setUp() self.task = MockTask() self.task.load() self.pipe = MockPipe() self.process = daemon.TaskProcess(self.task, os.getpid(), self.pipe)
def setUp(self): super(TestEnvironment, self).setUp() self.setup_dir() self.env = Environment(data_dir=self.test_dir, io=MockIOStream(), task=MockTask())
def setUp(self): super(TestAppRun, self).setUp() self.setup_dir() self.task = MockTask() self.plugin = plugins.AppRun()
def setUp(self): super(TestAppBlock, self).setUp() self.task = MockTask() self.plugin = plugins.AppBlock()
def setUp(self): super(TestAppClose, self).setUp() self.task = MockTask() self.plugin = plugins.AppClose()