def test_increment_metric_correct(self):
sched = scheduler.Scheduler(3, 0.5)
sched._set_metric("a", "1")
sched._increment_metric("a")
self.assertEqual(sched._get_metric("a"), 2)
sched._increment_metric("a")
self.assertEqual(sched._get_metric("a"), 3)
def test_process_callback_1(self):
sched = scheduler.Scheduler(2, 0.5)
sched.on_task_started = mock.Mock()
sched.on_task_cancelled = mock.Mock()
sched.on_task_succeeded = mock.Mock()
sched.on_task_failed = mock.Mock()
# mock pipe + connection receiver
msg1 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_TASK_STARTED)
msg2 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_TASK_FAILED)
msg3 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_TASK_SUCCEEDED)
msg4 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_TASK_CANCELLED)
conn1 = mock.Mock()
conn1.poll.side_effect = [True, True, True, True, True, False]
conn1.recv.side_effect = [msg1, msg1, msg2, msg3, msg4]
sched.pipe = {"a": conn1}
# process callback
sched._process_callback()
# check function calls
sched.on_task_started.assert_called_once_with([msg1, msg1])
sched.on_task_failed.assert_called_once_with([msg2])
sched.on_task_succeeded.assert_called_once_with([msg3])
sched.on_task_cancelled.assert_called_once_with([msg4])
def test_prepare_polling_thread(self):
sched = scheduler.Scheduler(3, 0.5)
# check polling thread without consumer
thread = sched._prepare_polling_thread("test")
self.assertNotEqual(thread, None)
self.assertEqual(thread.daemon, True)
self.assertEqual(thread.name, "test")
def setUp(self):
self.msg = []
self.sched = scheduler.Scheduler(2, timeout=1)
self.scenario = Scenario(
"finish-cancel",
[2, OkTask("1", const.PRIORITY_2, 3), 1, OkTask("2", const.PRIORITY_1, 7), 5]
)
def test_init_1(self):
sched = scheduler.Scheduler(3, 0.5)
self.assertEqual(sched.num_executors, 3)
self.assertEqual(sched.timeout, 0.5)
self.assertEqual(sched.on_task_started, None)
self.assertEqual(sched.on_task_cancelled, None)
self.assertEqual(sched.on_task_succeeded, None)
self.assertEqual(sched.on_task_failed, None)
def test_get_is_alive_statuses(self):
sched = scheduler.Scheduler(3, 0.5)
sched.is_alive_statuses["a"] = 1
sched.is_alive_statuses["b"] = 2
copy = sched.get_is_alive_statuses()
self.assertEqual(copy, sched.is_alive_statuses)
copy["a"] = 2
self.assertNotEqual(copy, sched.is_alive_statuses)
def setUp(self):
self.msg = []
self.sched = scheduler.Scheduler(2, timeout=1)
self.scenario = Scenario("failed-tasks", [
2,
FailTask("1", const.PRIORITY_2, 2),
1,
FailTask("2", const.PRIORITY_1, 3),
5
])
def test_prepare_executor(self):
sched = scheduler.Scheduler(3, 0.5)
# prepare mock executor
exc = sched._prepare_executor("test")
# assertions
self.assertTrue(isinstance(exc, scheduler.Executor))
self.assertEqual(exc.daemon, True)
self.assertEqual(exc.name, "Executor[test]")
self.assertEqual(sched.executors, [exc])
self.assertTrue(exc.name in sched.pipe)
def test_start(self):
sched = scheduler.Scheduler(3, 0.5)
mock_exc = mock.Mock()
sched._prepare_executor = mock.Mock()
sched._prepare_executor.return_value = mock_exc
# launch executor
sched.start()
# assertions, check that prepare_executor was called number of executors times
self.assertEqual(sched._prepare_executor.call_count, 3)
self.assertEqual(mock_exc.start.call_count, 3)
def test_start_maintenance(self):
sched = scheduler.Scheduler(3, 0.5)
sched._prepare_polling_thread = mock.Mock()
mock_thread = mock.Mock()
sched._prepare_polling_thread.return_value = mock_thread
# launch maintenance should not result in any error
sched.start_maintenance()
mock_thread.start.assert_called_once_with()
# launch maintenance when thread is None
sched._prepare_polling_thread.return_value = None
sched.start_maintenance()
def setUp(self):
self.msg = []
self.sched = scheduler.Scheduler(2, timeout=1)
self.scenario = Scenario("cancel-ahead", [
1,
"cancel:1", # task id, not a uid of OkTask
2,
OkTask("1", const.PRIORITY_2, 3),
1,
OkTask("2", const.PRIORITY_1, 7),
5
])
def test_update_is_alive(self):
sched = scheduler.Scheduler(1, 0.5)
msg1 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_IS_ALIVE,
arguments={"name": "x"})
msg2 = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_IS_ALIVE,
arguments={})
self.assertTrue("x" not in sched.is_alive_statuses)
sched.is_alive_statuses = {}
sched._update_is_alive([msg1, msg2])
self.assertEqual(len(sched.is_alive_statuses), 1)
self.assertTrue("x" in sched.is_alive_statuses)
def test_cancel(self):
sched = scheduler.Scheduler(3, 0.5)
# no task_id provided -> no-op
sched.pipe = mock.Mock()
sched.cancel(None)
self.assertEqual(sched.pipe.values.call_count, 0)
# task_id provided, and connections are available
mock_conn = mock.Mock()
sched.pipe.values = mock.Mock()
sched.pipe.values.return_value = [mock_conn]
sched.cancel("123")
sched.pipe.values.assert_called_once_with()
conn_msg = "call(Message[EXECUTOR_CANCEL_TASK]{'task_id': '123'})"
self.assertEqual(str(mock_conn.send.call_args_list[0]), conn_msg)
def test_process_callback_4(self):
# test of 'is alive' messages
sched = scheduler.Scheduler(2, 0.5)
sched.on_is_alive = mock.Mock()
msg = mock.create_autospec(scheduler.Message,
status=scheduler.EXECUTOR_IS_ALIVE)
conn = mock.Mock()
conn.poll.side_effect = [True, False]
conn.recv.side_effect = [msg]
sched.pipe = {"a": conn}
# process callback
sched._process_callback()
# check function calls
sched.on_is_alive.assert_called_once_with([msg])
def test_process_callback_3(self):
sched = scheduler.Scheduler(2, 0.5)
sched.on_task_started = mock.Mock()
sched.on_task_cancelled = mock.Mock()
sched.on_task_succeeded = mock.Mock()
sched.on_task_failed = mock.Mock()
# mock pipe + connection receiver
sched.pipe = None
# process callback
sched._process_callback()
# check function calls
self.assertEqual(sched.on_task_started.call_count, 0)
self.assertEqual(sched.on_task_failed.call_count, 0)
self.assertEqual(sched.on_task_succeeded.call_count, 0)
self.assertEqual(sched.on_task_cancelled.call_count, 0)
def test_process_callback_2(self):
sched = scheduler.Scheduler(2, 0.5)
sched.on_task_started = mock.Mock()
sched.on_task_cancelled = mock.Mock()
sched.on_task_succeeded = mock.Mock()
sched.on_task_failed = mock.Mock()
# mock pipe + connection receiver
msg = mock.Mock()
conn1 = mock.Mock()
conn1.poll.side_effect = [True, True, True, True, True, False]
conn1.recv.side_effect = [msg, msg, msg, msg, msg]
sched.pipe = {"a": conn1}
# process callback
sched._process_callback()
# check function calls
self.assertEqual(sched.on_task_started.call_count, 0)
self.assertEqual(sched.on_task_failed.call_count, 0)
self.assertEqual(sched.on_task_succeeded.call_count, 0)
self.assertEqual(sched.on_task_cancelled.call_count, 0)
def test_stop(self, mock_time):
mock_time.sleep.return_value = None
sched = scheduler.Scheduler(3, 0.5)
mock_conn = mock.Mock()
sched.pipe = {"executor_name": mock_conn}
mock_exc_1 = mock.Mock()
mock_exc_2 = mock.Mock()
mock_exc_2.is_alive.return_value = False
sched.executors = [mock_exc_1, mock_exc_2]
# stop scheduler
sched.stop()
# assertions
self.assertEqual(sched.pipe, None)
self.assertEqual(sched.executors, None)
self.assertEqual(sched.task_queue_map, None)
self.assertEqual(mock_conn.send.call_count, 1)
# verify termination of executors
mock_exc_1.is_alive.assert_called_once_with()
mock_exc_1.terminate.assert_called_once_with()
mock_exc_1.join.assert_called_once_with()
mock_exc_2.is_alive.assert_called_once_with()
self.assertEqual(mock_exc_2.terminate.call_count, 0)
mock_exc_2.join.assert_called_once_with()
def test_submit_correct(self):
sched = scheduler.Scheduler(3, 0.5)
self.task.priority = const.PRIORITY_0
sched.task_queue_map = {
const.PRIORITY_0: mock.Mock(),
const.PRIORITY_1: mock.Mock(),
const.PRIORITY_2: mock.Mock()
}
task_id = sched.submit(self.task)
# assertions
self.assertEqual(
sched.task_queue_map[const.PRIORITY_0].put_nowait.call_count, 1)
self.assertEqual(
sched.task_queue_map[const.PRIORITY_1].put_nowait.call_count, 0)
self.assertEqual(
sched.task_queue_map[const.PRIORITY_2].put_nowait.call_count, 0)
args = sched.task_queue_map[
const.PRIORITY_0].put_nowait.call_args_list[0][0]
self.assertEqual(len(args), 1) # expect only one call
self.assertEqual(args[0].uid, 0) # first task launch
self.assertEqual(
task_id, 0) # should be the same task id that is assigned to task
self.assertEqual(args[0].task, self.task)
self.assertEqual(args[0].info, None)
def test_submit_wrong_type(self):
sched = scheduler.Scheduler(3, 0.5)
with self.assertRaises(TypeError):
sched.submit(mock.Mock())
def test_get_metric(self):
sched = scheduler.Scheduler(3, 0.5)
self.assertEqual(sched._get_metric("a"), None)
def test_set_metric(self):
sched = scheduler.Scheduler(3, 0.5)
sched._set_metric("a", 1)
self.assertEqual(sched._get_metric("a"), 1)
sched._set_metric("a", 2)
self.assertEqual(sched._get_metric("a"), 2)
def test_increment_metric_nonexistent(self):
sched = scheduler.Scheduler(3, 0.5)
sched._increment_metric("a")
self.assertEqual(sched._get_metric("a"), None)
def test_increment_metric_convert_error(self):
sched = scheduler.Scheduler(3, 0.5)
sched._set_metric("a", "b")
sched._increment_metric("a")
self.assertEqual(sched._get_metric("a"), 0)
def setUp(self):
self.msg = []
self.sched = scheduler.Scheduler(1, timeout=1)
self.scenario = Scenario("simple", [1, OkTask("1", const.PRIORITY_1, 2), 4])
def __init__(self, num_executors, timeout=1.0):
self.num_executors = num_executors
self.timeout = timeout
self._scheduler = scheduler.Scheduler(self.num_executors,
timeout=self.timeout)
def test_submit_wrong_priority(self):
sched = scheduler.Scheduler(3, 0.5)
self.task.priority = "abc"
with self.assertRaises(KeyError):
sched.submit(self.task)
def test_get_num_executors(self):
sched = scheduler.Scheduler(3, 0.5)
self.assertEqual(sched.get_num_executors(), 3)
sched = scheduler.Scheduler(1, 0.5)
self.assertEqual(sched.get_num_executors(), 1)
def test_get_metrics(self):
sched = scheduler.Scheduler(3, 0.5)
sched._set_metric("a", "1")
sched._set_metric("b", 1)
self.assertEqual(sched.get_metrics(), {"a": "1", "b": 1})
def test_prepare_executor_wrong_type(self):
sched = scheduler.Scheduler(3, 0.5)
sched.executor_class = mock.Mock()
# prepare mock executor
with self.assertRaises(TypeError):
sched._prepare_executor("test")
def test_init_2(self):
with self.assertRaises(ValueError):
scheduler.Scheduler("abc", 0.5)
