def test_process_task_empty(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
mock_task_thread = mock.Mock()
exc._get_new_task = mock.Mock()
exc._get_new_task.return_value = mock_task_thread
exc._process_task()
self.assertEqual(exc._active_task, mock_task_thread)
def test_init_2(self):
exc = scheduler.Executor("name", self.conn, self.queue_map, timeout=10)
self.assertEqual(exc.name, "Executor[name]")
self.assertEqual(exc.conn, self.conn)
self.assertEqual(exc.task_queue_map, self.queue_map)
self.assertEqual(exc.timeout, 10)
self.assertEqual(exc._cancel_task_ids, set())
def test_respond_is_alive(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._respond_is_alive()
self.assertEqual(self.conn.send.call_count, 1)
self.assertEqual(len(self.conn.send.call_args_list), 1)
msg = self.conn.send.call_args_list[0][0][0]
self.assertEqual(msg.status, scheduler.EXECUTOR_IS_ALIVE)
self.assertEqual(msg.arguments["name"], "Executor[a]")
def test_iteration_valid_task_no_poll(self):
self.conn.poll.return_value = False
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._process_message = mock.create_autospec(exc._process_message)
exc._process_task = mock.create_autospec(exc._process_task)
self.assertEqual(exc.iteration(), True)
self.assertEqual(exc._process_message.call_count, 0)
exc._process_task.assert_called_once_with()
def test_process_message_cancel_task(self, mock_logger):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
msg_mock = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_CANCEL_TASK,
arguments={"task_id": "123"})
exc._process_message(msg_mock)
self.assertTrue("123" in exc._cancel_task_ids)
mock_logger.debug.assert_called_with(
"%s - Registered cancelled task %s", "Executor[a]", "123")
def test_process_task_started(self, mock_logger):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._active_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
is_alive=True,
status=scheduler.TASK_STARTED)
exc._process_task()
mock_logger.debug.assert_called_with("%s - Ping task %s is alive",
"Executor[a]", "123")
def test_process_task_cancel_ahead(self):
exc = scheduler.Executor("a", self.conn, {}, timeout=1)
exc._active_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
status=scheduler.TASK_PENDING)
exc._cancel_task_ids.add("123")
exc._process_task()
self.assertEqual(exc._active_task, None)
self.assertTrue("123" not in exc._cancel_task_ids)
def test_get_new_task_priority2_queue(self):
# prepare mock queues
self.queue_map[const.PRIORITY_0].get.side_effect = threadqueue.Empty()
self.queue_map[const.PRIORITY_1].get.side_effect = threadqueue.Empty()
self.queue_map[
const.PRIORITY_2].get.return_value = self.mock_task_block
# should select priority 2
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
thread = exc._get_new_task()
self.assertTrue(isinstance(thread, scheduler.TaskThread))
def test_process_task_pending_not_available(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._active_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
status=scheduler.TASK_PENDING)
exc.external_system_available = mock.Mock()
exc.external_system_available.return_value = False
exc._process_task()
self.assertEqual(exc._active_task.start.call_count, 0)
self.assertEqual(self.conn.send.call_count, 0)
def test_process_task_pending(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._active_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
status=scheduler.TASK_PENDING,
task_info="abc")
exc._process_task()
exc._active_task.start.assert_called_once_with()
self.assertEqual(len(self.conn.send.call_args_list), 1)
conn_msg = "call(Message[EXECUTOR_TASK_STARTED]{'info': 'abc', 'task_id': '123'})"
self.assertEqual(str(self.conn.send.call_args_list[0]), conn_msg)
def test_process_task_cancel(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
mock_task_thread = mock.Mock()
mock_task_thread.uid = "123"
exc._get_new_task = mock.Mock()
exc._get_new_task.return_value = mock_task_thread
exc._cancel_active_task = mock.Mock()
exc._cancel_task_ids.add("123")
exc._process_task()
self.assertFalse("123" in exc._cancel_task_ids)
exc._cancel_active_task.assert_called_once_with()
def test_run(self, mock_time):
# test time.sleep, if iteration returns True, `time.sleep` is called
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc.iteration = mock.create_autospec(exc.iteration, return_value=False)
self.assertEqual(exc.run(), False)
self.assertEqual(mock_time.sleep.call_count, 0)
# test when iteration returns True, and then False
exc.iteration = mock.Mock()
exc.iteration.side_effect = [True, True, False]
self.assertEqual(exc.run(), False)
self.assertEqual(mock_time.sleep.call_count, 2)
def test_process_task_failed(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._active_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
status=scheduler.TASK_FAILED,
task_info="abc")
exc._process_task()
self.assertEqual(len(self.conn.send.call_args_list), 1)
conn_msg = "call(Message[EXECUTOR_TASK_FAILED]{'info': 'abc', 'task_id': '123'})"
self.assertEqual(str(self.conn.send.call_args_list[0]), conn_msg)
self.assertEqual(exc._active_task, None)
def test_iteration_terminate(self):
self.conn.poll.return_value = True
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._process_message = mock.create_autospec(exc._process_message)
exc._process_message.side_effect = scheduler.ExecutorInterruptedException(
)
exc._process_task = mock.create_autospec(exc._process_task)
exc._cancel_active_task = mock.create_autospec(exc._cancel_active_task)
self.assertEqual(exc.iteration(), False)
self.assertEqual(exc._terminated, True)
self.assertEqual(exc._process_task.call_count, 0)
exc._cancel_active_task.assert_called_once_with()
def test_cancel_active_task_2(self):
exc = scheduler.Executor("a", self.conn, {}, timeout=1)
mock_task = mock.create_autospec(scheduler.TaskThread,
uid="123",
status=scheduler.TASK_STARTED,
task_info="abc")
exc._active_task = mock_task
exc._cancel_active_task()
self.assertEqual(exc._active_task, None)
mock_task.cancel.assert_called_once_with()
self.assertEqual(len(self.conn.send.call_args_list), 1)
conn_msg = "call(Message[EXECUTOR_TASK_CANCELLED]{'info': 'abc', 'task_id': '123'})"
self.assertEqual(str(self.conn.send.call_args_list[0]), conn_msg)
def test_get_new_task_empty_queue(self):
# prepare mock queues
for queue in self.queue_map.values():
queue.get.side_effect = threadqueue.Empty()
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
self.assertEqual(exc._get_new_task(), None)
def test_iteration_terminate_global(self):
self.conn.poll.return_value = True
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._process_message = mock.create_autospec(exc._process_message)
exc._process_message.side_effect = StandardError()
self.assertEqual(exc.iteration(), False)
def test_process_message_shutdown(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
msg_mock = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_SHUTDOWN)
with self.assertRaises(scheduler.ExecutorInterruptedException):
exc._process_message(msg_mock)
def test_iteration_executor_terminated(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._terminated = True
self.assertEqual(exc.iteration(), False)
def test_cancel_active_task_1(self, mock_logger):
exc = scheduler.Executor("a", self.conn, {}, timeout=1)
exc._active_task = None
exc._cancel_active_task()
mock_logger.info.assert_called_once_with(
"%s - No active task to cancel", "Executor[a]")
def test_process_task_no_tasks(self, mock_logger):
exc = scheduler.Executor("a", self.conn, {}, timeout=1)
exc._active_task = None
exc._process_task()
mock_logger.debug.assert_called_with("%s - No active task registered",
"Executor[a]")
def test_get_new_task_empty_map(self):
exc = scheduler.Executor("a", self.conn, {}, timeout=1)
self.assertEqual(exc._get_new_task(), None)
def test_process_task_cancelled(self):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._active_task = mock.create_autospec(
scheduler.TaskThread, uid="123", status=scheduler.TASK_CANCELLED)
exc._process_task()
self.assertEqual(exc._active_task, None)
def test_process_message_invalid(self, mock_logger):
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
exc._process_message(None)
mock_logger.info.assert_called_once_with(
"%s - Invalid message %s is ignored", "Executor[a]", None)
