def test_hold(self, reporter, dep_manager):
run = runner.MRunner(dep_manager, reporter)
task_q = Queue()
task_q.put(runner.JobHold()) # to test
task_q.put(None) # to terminate function
result_q = Queue()
run.execute_task_subprocess(task_q, result_q, reporter.__class__)
run.finish()
# nothing was done
assert result_q.empty()
def test_hold(self, reporter, depfile):
run = runner.MRunner(depfile.name, reporter)
task_q = Queue()
task_q.put(runner.Hold()) # to test
task_q.put(None) # to terminate function
result_q = Queue()
run.execute_task_subprocess(task_q, result_q)
run.finish()
# nothing was done
assert result_q.empty() # pragma: no cover (coverage bug?)
def test_stop_running(self, reporter, dep_manager):
t1 = Task('t1', [])
t2 = Task('t2', [])
run = runner.MRunner(dep_manager, reporter)
run._run_tasks_init(
TaskDispatcher({
't1': t1,
't2': t2
}, [], ['t1', 't2']))
assert t1.name == run.get_next_job(None).name
run._stop_running = True
assert None == run.get_next_job(None)
def test_stop_running(self, reporter, depfile_name):
t1 = Task('t1', [])
t2 = Task('t2', [])
run = runner.MRunner(Dependency, depfile_name, reporter)
run._run_tasks_init(
TaskDispatcher({
't1': t1,
't2': t2
}, [], ['t1', 't2']))
assert t1 == run.get_next_task(None).task
run._stop_running = True
assert None == run.get_next_task(None)
def test_run_task(self, reporter, depfile):
t1 = Task('t1', [])
t2 = Task('t2', [])
run = runner.MRunner(depfile.name, reporter)
run._run_tasks_init(
TaskDispatcher({
't1': t1,
't2': t2
}, [], ['t1', 't2']))
assert t1 == run.get_next_task(None).task
assert t2 == run.get_next_task(None).task
assert None == run.get_next_task(None)
def test_waiting_controller(self, reporter, dep_manager):
t1 = Task('t1', [])
t2 = Task('t2', [], calc_dep=('t1',))
run = runner.MRunner(dep_manager, reporter)
run._run_tasks_init(TaskDispatcher({'t1':t1, 't2':t2}, [], ['t1', 't2']))
# first task ok
assert t1.name == run.get_next_job(None).name
# hold until t1 finishes
assert 0 == run.free_proc
assert isinstance(run.get_next_job(None), runner.JobHold)
assert 1 == run.free_proc
def test_less_processes(self, reporter, monkeypatch, dep_manager):
mock_process = Mock()
monkeypatch.setattr(runner.MRunner, 'Child', mock_process)
t1 = Task('t1', [])
td = TaskDispatcher({'t1': t1}, [], ['t1'])
run = runner.MRunner(dep_manager, reporter, num_process=2)
run._run_tasks_init(td)
result_q = Queue()
task_q = Queue()
proc_list = run._run_start_processes(task_q, result_q)
run.finish()
assert 1 == len(proc_list)
assert t1.name == task_q.get().name
def test_full_task(self, reporter, dep_manager):
# test execute_task_subprocess can receive a full Task object
run = runner.MRunner(dep_manager, reporter)
t1 = Task('t1', [simple_result])
task_q = Queue()
task_q.put(runner.JobTask(t1)) # to test
task_q.put(None) # to terminate function
result_q = Queue()
run.execute_task_subprocess(task_q, result_q, reporter.__class__)
run.finish()
# check result
assert result_q.get() == {'name': 't1', 'reporter': 'execute_task'}
assert result_q.get()['task']['result'] == 'my-result'
assert result_q.empty()
def test_waiting_process(self, reporter, monkeypatch, dep_manager):
mock_process = Mock()
monkeypatch.setattr(runner.MRunner, 'Child', mock_process)
t1 = Task('t1', [])
t2 = Task('t2', [], task_dep=['t1'])
td = TaskDispatcher({'t1': t1, 't2': t2}, [], ['t1', 't2'])
run = runner.MRunner(dep_manager, reporter, num_process=2)
run._run_tasks_init(td)
result_q = Queue()
task_q = Queue()
proc_list = run._run_start_processes(task_q, result_q)
run.finish()
assert 2 == len(proc_list)
assert t1.name == task_q.get().name
assert isinstance(task_q.get(), runner.JobHold)
def test_all_processes(self, reporter, monkeypatch, depfile_name):
mock_process = Mock()
monkeypatch.setattr(runner.MRunner, 'Child', mock_process)
t1 = Task('t1', [])
t2 = Task('t2', [])
td = TaskDispatcher({'t1': t1, 't2': t2}, [], ['t1', 't2'])
run = runner.MRunner(Dependency, depfile_name, reporter, num_process=2)
run._run_tasks_init(td)
result_q = Queue()
task_q = Queue()
proc_list = run._run_start_processes(task_q, result_q)
run.finish()
assert 2 == len(proc_list)
assert t1.name == task_q.get().name
assert t2.name == task_q.get().name
def test_waiting_controller(self, reporter, depfile_name):
t1 = Task('t1', [])
t2 = Task('t2', [], calc_dep=('t1', ))
run = runner.MRunner(Dependency, depfile_name, reporter)
run._run_tasks_init(
TaskDispatcher({
't1': t1,
't2': t2
}, [], ['t1', 't2']))
# first task ok
assert t1 == run.get_next_task(None).task
# hold until t1 finishes
assert 0 == run.free_proc
assert isinstance(run.get_next_task(None), runner.Hold)
assert 1 == run.free_proc
def test_waiting(self, reporter, depfile_name):
t1 = Task('t1', [])
t2 = Task('t2', [], setup=('t1', ))
run = runner.MRunner(Dependency, depfile_name, reporter)
run._run_tasks_init(TaskDispatcher({'t1': t1, 't2': t2}, [], ['t2']))
# first start task 1
n1 = run.get_next_task(None)
assert t1 == n1.task
# hold until t1 is done
assert isinstance(run.get_next_task(None), runner.Hold)
assert isinstance(run.get_next_task(None), runner.Hold)
n1.run_status = 'done'
n2 = run.get_next_task(n1)
assert t2 == n2.task
assert None == run.get_next_task(n2)
def test_full_task_fail(self, reporter, dep_manager):
# test execute_task_subprocess can receive a full Task object
run = runner.MRunner(dep_manager, reporter)
t1 = Task('t1', [simple_fail])
task_q = Queue()
task_q.put(runner.JobTask(t1)) # to test
task_q.put(None) # to terminate function
result_q = Queue()
run.execute_task_subprocess(task_q, result_q, reporter.__class__)
run.finish()
# check result
assert result_q.get() == {'name': 't1', 'reporter': 'execute_task'}
res = result_q.get()
assert res['name'] == 't1'
assert isinstance(res['failure'], CatchedException)
assert res['out'] == ['simple output\n']
assert res['err'] == ['simple error\n']
# assert result_q.get()['task']['result'] == 'my-result'
assert result_q.empty()
def test_delayed_loaded(self, reporter, dep_manager):
def create():
return {'basename':'t1', 'actions': None}
t1 = Task('t1', [], loader=DelayedLoader(create, executed='t2'))
t2 = Task('t2', [])
run = runner.MRunner(dep_manager, reporter)
dispatcher = TaskDispatcher({'t1':t1, 't2':t2}, [], ['t1', 't2'])
run._run_tasks_init(dispatcher)
assert t2.name == run.get_next_job(None).name
assert runner.JobHold.type == run.get_next_job(None).type
# after t2 is done t1 can be dispatched
n2 = dispatcher.nodes[t2.name]
n2.run_status = 'done'
j1 = run.get_next_job(n2)
assert t1.name == j1.name
# the job for t1 contains the whole task since sub-process dont
# have it
assert j1.type == runner.JobTask.type
def test_waiting(self, reporter, dep_manager):
t1 = Task('t1', [])
t2 = Task('t2', [], setup=('t1', ))
run = runner.MRunner(dep_manager, reporter)
dispatcher = TaskDispatcher({'t1': t1, 't2': t2}, [], ['t2'])
run._run_tasks_init(dispatcher)
# first start task 1
j1 = run.get_next_job(None)
assert t1.name == j1.name
# hold until t1 is done
assert isinstance(run.get_next_job(None), runner.JobHold)
assert isinstance(run.get_next_job(None), runner.JobHold)
n1 = dispatcher.nodes[j1.name]
n1.run_status = 'done'
j2 = run.get_next_job(n1)
assert t2.name == j2.name
assert None == run.get_next_job(dispatcher.nodes[j2.name])
